結果

問題 No.1204 お菓子配り-FINAL
ユーザー PCTprobabilityPCTprobability
提出日時 2020-08-28 16:45:05
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 5,184 ms / 8,000 ms
コード長 15,286 bytes
コンパイル時間 6,301 ms
コンパイル使用メモリ 377,560 KB
実行使用メモリ 120,744 KB
最終ジャッジ日時 2024-11-17 12:52:36
合計ジャッジ時間 101,589 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 324 ms
120,740 KB
testcase_01 AC 377 ms
120,620 KB
testcase_02 AC 326 ms
120,676 KB
testcase_03 AC 303 ms
120,648 KB
testcase_04 AC 387 ms
120,648 KB
testcase_05 AC 334 ms
120,564 KB
testcase_06 AC 335 ms
120,628 KB
testcase_07 AC 354 ms
120,512 KB
testcase_08 AC 317 ms
120,532 KB
testcase_09 AC 308 ms
120,604 KB
testcase_10 AC 363 ms
120,484 KB
testcase_11 AC 342 ms
120,512 KB
testcase_12 AC 344 ms
120,588 KB
testcase_13 AC 352 ms
120,652 KB
testcase_14 AC 318 ms
120,612 KB
testcase_15 AC 298 ms
120,632 KB
testcase_16 AC 317 ms
120,712 KB
testcase_17 AC 292 ms
120,608 KB
testcase_18 AC 314 ms
120,612 KB
testcase_19 AC 311 ms
120,692 KB
testcase_20 AC 389 ms
120,700 KB
testcase_21 AC 992 ms
120,728 KB
testcase_22 AC 365 ms
120,572 KB
testcase_23 AC 551 ms
120,708 KB
testcase_24 AC 436 ms
120,652 KB
testcase_25 AC 295 ms
120,664 KB
testcase_26 AC 510 ms
120,664 KB
testcase_27 AC 840 ms
120,564 KB
testcase_28 AC 280 ms
120,692 KB
testcase_29 AC 525 ms
120,644 KB
testcase_30 AC 567 ms
120,680 KB
testcase_31 AC 746 ms
120,636 KB
testcase_32 AC 318 ms
120,616 KB
testcase_33 AC 535 ms
120,616 KB
testcase_34 AC 366 ms
120,628 KB
testcase_35 AC 425 ms
120,676 KB
testcase_36 AC 613 ms
120,496 KB
testcase_37 AC 562 ms
120,660 KB
testcase_38 AC 368 ms
120,468 KB
testcase_39 AC 410 ms
120,520 KB
testcase_40 AC 391 ms
120,500 KB
testcase_41 AC 297 ms
120,644 KB
testcase_42 AC 285 ms
120,524 KB
testcase_43 AC 303 ms
120,680 KB
testcase_44 AC 287 ms
120,744 KB
testcase_45 AC 293 ms
120,652 KB
testcase_46 AC 289 ms
120,604 KB
testcase_47 AC 300 ms
120,532 KB
testcase_48 AC 379 ms
120,660 KB
testcase_49 AC 369 ms
120,652 KB
testcase_50 AC 366 ms
120,612 KB
testcase_51 AC 314 ms
120,592 KB
testcase_52 AC 303 ms
120,628 KB
testcase_53 AC 327 ms
120,588 KB
testcase_54 AC 397 ms
120,492 KB
testcase_55 AC 298 ms
120,600 KB
testcase_56 AC 367 ms
120,668 KB
testcase_57 AC 289 ms
120,560 KB
testcase_58 AC 320 ms
120,572 KB
testcase_59 AC 336 ms
120,644 KB
testcase_60 AC 294 ms
120,580 KB
testcase_61 AC 286 ms
120,520 KB
testcase_62 AC 294 ms
120,596 KB
testcase_63 AC 283 ms
120,592 KB
testcase_64 AC 291 ms
120,664 KB
testcase_65 AC 290 ms
120,568 KB
testcase_66 AC 286 ms
120,644 KB
testcase_67 AC 302 ms
120,604 KB
testcase_68 AC 302 ms
120,632 KB
testcase_69 AC 296 ms
120,672 KB
testcase_70 AC 301 ms
120,616 KB
testcase_71 AC 300 ms
120,492 KB
testcase_72 AC 287 ms
120,488 KB
testcase_73 AC 287 ms
120,608 KB
testcase_74 AC 297 ms
120,600 KB
testcase_75 AC 293 ms
120,648 KB
testcase_76 AC 285 ms
120,592 KB
testcase_77 AC 292 ms
120,568 KB
testcase_78 AC 288 ms
120,556 KB
testcase_79 AC 296 ms
120,512 KB
testcase_80 AC 292 ms
120,620 KB
testcase_81 AC 289 ms
120,484 KB
testcase_82 AC 295 ms
120,612 KB
testcase_83 AC 294 ms
120,484 KB
testcase_84 AC 301 ms
120,684 KB
testcase_85 AC 279 ms
120,672 KB
testcase_86 AC 294 ms
120,668 KB
testcase_87 AC 282 ms
120,628 KB
testcase_88 AC 291 ms
120,600 KB
testcase_89 AC 281 ms
120,684 KB
testcase_90 AC 2,188 ms
120,480 KB
testcase_91 AC 757 ms
120,652 KB
testcase_92 AC 1,191 ms
120,552 KB
testcase_93 AC 2,606 ms
120,544 KB
testcase_94 AC 2,016 ms
120,680 KB
testcase_95 AC 2,956 ms
120,620 KB
testcase_96 AC 5,184 ms
120,608 KB
testcase_97 AC 756 ms
120,604 KB
testcase_98 AC 2,175 ms
120,632 KB
testcase_99 AC 2,899 ms
120,616 KB
testcase_100 AC 460 ms
120,640 KB
testcase_101 AC 2,091 ms
120,520 KB
testcase_102 AC 3,962 ms
120,636 KB
testcase_103 AC 3,542 ms
120,624 KB
testcase_104 AC 4,559 ms
120,612 KB
testcase_105 AC 644 ms
120,628 KB
testcase_106 AC 312 ms
120,592 KB
testcase_107 AC 491 ms
120,664 KB
testcase_108 AC 2,240 ms
120,704 KB
testcase_109 AC 2,801 ms
120,556 KB
testcase_110 AC 729 ms
120,496 KB
testcase_111 AC 447 ms
120,700 KB
testcase_112 AC 434 ms
120,620 KB
testcase_113 AC 528 ms
120,608 KB
testcase_114 AC 636 ms
120,656 KB
testcase_115 AC 628 ms
120,628 KB
testcase_116 AC 731 ms
120,516 KB
testcase_117 AC 656 ms
120,600 KB
testcase_118 AC 392 ms
120,644 KB
testcase_119 AC 822 ms
120,608 KB
testcase_120 AC 1,120 ms
120,476 KB
testcase_121 AC 442 ms
120,612 KB
testcase_122 AC 735 ms
120,640 KB
testcase_123 AC 391 ms
120,632 KB
testcase_124 AC 1,018 ms
120,624 KB
testcase_125 AC 919 ms
120,636 KB
testcase_126 AC 644 ms
120,584 KB
testcase_127 AC 637 ms
120,616 KB
testcase_128 AC 633 ms
120,660 KB
testcase_129 AC 1,929 ms
120,732 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

////////////////////////////////////////////////////////////////////////////////
//                          Give me AC!!!                                     //
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <random>
#include <cmath>
#include <limits>
#include <iostream>
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
namespace mp = boost::multiprecision;
using namespace mp;
using ull = __int128;
using ll = long long;
using cll = cpp_int;
using Graph = vector<vector<int>>; 
#define coutY cout<<"YES"<<endl
#define couty cout<<"Yes"<<endl
#define coutN cout<<"NO"<<endl
#define coutn cout<<"No"<<endl
#define coutdouble(a,b) cout << fixed << setprecision(a) << double(b) ;
#define vi(a,b) vector<int> a(b)
#define vl(a,b) vector<ll> a(b)
#define vs(a,b) vector<string> a(b)
#define vll(a,b,c)  vector<vector<ll>> a(b, vector<ll>(c));
#define intque(a) queue<int> a;
#define llque(a) queue<ll> a;
#define intque2(a) priority_queue<int, vector<int>, greater<int>> a;
#define llque2(a) priority_queue<ll, vector<ll>, greater<ll>> a;
#define pushback(a,b) a.push_back(b)
#define mapii(M1) map<int, int> M1;
#define cou(v,x) count(v.begin(), v.end(), x)
#define mapll(M1) map<ll,ll> M1;
#define mapls(M1) map<ll, string> M1;
#define mapsl(M1) map<string, ll> M1;
#define twolook(a,l,r,x) lower_bound(a+l, a+r, x) - a
#define sor(a) sort(a.begin(), a.end())
#define rever(a) reverse(a.begin(),a.end())
#define rep(i,a) for(ll i=0;i<a;i++)
#define vcin(n) for(ll i=0;i<ll(n.size());i++) cin>>n[i]
#define vcout(n) for(ll i=0;i<ll(n.size());i++) cout<<n[i]
#define vcin2(n) rep(i,ll(n.size())) rep(j,ll(n.at(0).size())) cin>>n[i][j]
constexpr ll mod = 1000000007;
constexpr ll MOD = 1000000007;
constexpr ll MAX = 5000000;
//const ll _max = 9223372036854775807;
const ll _max = 1223372036854775807;
  
ll fac[MAX],finv[MAX],inv[MAX];

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
long long COM(ll n,ll k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

template< int mod >
struct ModInt {
  int x;

  ModInt() : x(0) {}

  ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

  ModInt &operator+=(const ModInt &p) {
    if((x += p.x) >= mod) x -= mod;
    return *this;
  }

  ModInt &operator-=(const ModInt &p) {
    if((x += mod - p.x) >= mod) x -= mod;
    return *this;
  }

  ModInt &operator*=(const ModInt &p) {
    x = (int) (1LL * x * p.x % mod);
    return *this;
  }

  ModInt &operator/=(const ModInt &p) {
    *this *= p.inverse();
    return *this;
  }

  ModInt operator-() const { return ModInt(-x); }

  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }

  ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }

  ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }

  ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }

  bool operator==(const ModInt &p) const { return x == p.x; }

  bool operator!=(const ModInt &p) const { return x != p.x; }

  ModInt inverse() const {
    int a = x, b = mod, u = 1, v = 0, t;
    while(b > 0) {
      t = a / b;
      swap(a -= t * b, b);
      swap(u -= t * v, v);
    }
    return ModInt(u);
  }

  ModInt pow(int64_t n) const {
    ModInt ret(1), mul(x);
    while(n > 0) {
      if(n & 1) ret *= mul;
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }

  friend ostream &operator<<(ostream &os, const ModInt &p) {
    return os << p.x;
  }

  friend istream &operator>>(istream &is, ModInt &a) {
    int64_t t;
    is >> t;
    a = ModInt< mod >(t);
    return (is);
  }

  static int get_mod() { return mod; }
};

using mint = ModInt< mod >;

int modPow(long long a, long long n, long long p) {
  if (n == 0) return 1; // 0乗にも対応する場合
  if (n == 1) return a % p;
  if (n % 2 == 1) return (a * modPow(a, n - 1, p)) % p;
  long long t = modPow(a, n / 2, p);
  return (t * t) % p;
}

ll clocks(ll a,ll b,ll c){
  return a*3600+b*60+c;
}
ll divup(ll b,ll d){
   if(b%d==0){
    return b/d;
  }
  else{
    return b/d+1;
  }
}
struct UnionFind {
    vector<int> par; // par[i]:iの親の番号　(例) par[3] = 2 : 3の親が2

    UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
        for(int i = 0; i < N; i++) par[i] = i;
    }

    int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
        if (par[x] == x) return x;
        return par[x] = root(par[x]);
    }

    void unite(int x, int y) { // xとyの木を併合
        int rx = root(x); //xの根をrx
        int ry = root(y); //yの根をry
        if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
        par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
    }

    bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
        int rx = root(x);
        int ry = root(y);
        return rx == ry;
    }
};

struct Edge {
    int to;     // 辺の行き先
    int weight; // 辺の重み
    Edge(int t, int w) : to(t), weight(w) { }
};

using Graphw = vector<vector<Edge>>;
ll zero(ll a){
  return max(ll(0),a);
}

template< typename T >
struct FormalPowerSeries : vector< T > {
  using vector< T >::vector;
  using P = FormalPowerSeries;

  using MULT = function< P(P, P) >;

  static MULT &get_mult() {
    static MULT mult = nullptr;
    return mult;
  }

  static void set_fft(MULT f) {
    get_mult() = f;
  }

  void shrink() {
    while(this->size() && this->back() == T(0)) this->pop_back();
  }

  P operator+(const P &r) const { return P(*this) += r; }

  P operator+(const T &v) const { return P(*this) += v; }

  P operator-(const P &r) const { return P(*this) -= r; }

  P operator-(const T &v) const { return P(*this) -= v; }

  P operator*(const P &r) const { return P(*this) *= r; }

  P operator*(const T &v) const { return P(*this) *= v; }

  P operator/(const P &r) const { return P(*this) /= r; }

  P operator%(const P &r) const { return P(*this) %= r; }

  P &operator+=(const P &r) {
    if(r.size() > this->size()) this->resize(r.size());
    for(int i = 0; i < r.size(); i++) (*this)[i] += r[i];
    return *this;
  }

  P &operator+=(const T &r) {
    if(this->empty()) this->resize(1);
    (*this)[0] += r;
    return *this;
  }

  P &operator-=(const P &r) {
    if(r.size() > this->size()) this->resize(r.size());
    for(int i = 0; i < r.size(); i++) (*this)[i] -= r[i];
    shrink();
    return *this;
  }

  P &operator-=(const T &r) {
    if(this->empty()) this->resize(1);
    (*this)[0] -= r;
    shrink();
    return *this;
  }

  P &operator*=(const T &v) {
    const int n = (int) this->size();
    for(int k = 0; k < n; k++) (*this)[k] *= v;
    return *this;
  }

  P &operator*=(const P &r) {
    if(this->empty() || r.empty()) {
      this->clear();
      return *this;
    }
    assert(get_mult() != nullptr);
    return *this = get_mult()(*this, r);
  }

  P &operator%=(const P &r) {
    return *this -= *this / r * r;
  }

  P operator-() const {
    P ret(this->size());
    for(int i = 0; i < this->size(); i++) ret[i] = -(*this)[i];
    return ret;
  }

  P &operator/=(const P &r) {
    if(this->size() < r.size()) {
      this->clear();
      return *this;
    }
    int n = this->size() - r.size() + 1;
    return *this = (rev().pre(n) * r.rev().inv(n)).pre(n).rev(n);
  }

  P pre(int sz) const {
    return P(begin(*this), begin(*this) + min((int) this->size(), sz));
  }

  P operator>>(int sz) const {
    if(this->size() <= sz) return {};
    P ret(*this);
    ret.erase(ret.begin(), ret.begin() + sz);
    return ret;
  }

  P operator<<(int sz) const {
    P ret(*this);
    ret.insert(ret.begin(), sz, T(0));
    return ret;
  }

  P rev(int deg = -1) const {
    P ret(*this);
    if(deg != -1) ret.resize(deg, T(0));
    reverse(begin(ret), end(ret));
    return ret;
  }

  P diff() const {
    const int n = (int) this->size();
    P ret(max(0, n - 1));
    for(int i = 1; i < n; i++) ret[i - 1] = (*this)[i] * T(i);
    return ret;
  }

  P integral() const {
    const int n = (int) this->size();
    P ret(n + 1);
    ret[0] = T(0);
    for(int i = 0; i < n; i++) ret[i + 1] = (*this)[i] / T(i + 1);
    return ret;
  }

  // F(0) must not be 0
  P inv(int deg = -1) const {
    assert(((*this)[0]) != T(0));
    const int n = (int) this->size();
    if(deg == -1) deg = n;
    P ret({T(1) / (*this)[0]});
    for(int i = 1; i < deg; i <<= 1) {
      ret = (ret + ret - ret * ret * pre(i << 1)).pre(i << 1);
    }
    return ret.pre(deg);
  }

  // F(0) must be 1
  P log(int deg = -1) const {
    assert((*this)[0] == 1);
    const int n = (int) this->size();
    if(deg == -1) deg = n;
    return (this->diff() * this->inv(deg)).pre(deg - 1).integral();
  }

  P sqrt(int deg = -1) const {
    const int n = (int) this->size();
    if(deg == -1) deg = n;

    if((*this)[0] == T(0)) {
      for(int i = 1; i < n; i++) {
        if((*this)[i] != T(0)) {
          if(i & 1) return {};
          if(deg - i / 2 <= 0) break;
          auto ret = (*this >> i).sqrt(deg - i / 2) << (i / 2);
          if(ret.size() < deg) ret.resize(deg, T(0));
          return ret;
        }
      }
      return P(deg, 0);
    }

    P ret({T(1)});
    T inv2 = T(1) / T(2);
    for(int i = 1; i < deg; i <<= 1) {
      ret = (ret + pre(i << 1) * ret.inv(i << 1)) * inv2;
    }
    return ret.pre(deg);
  }

  // F(0) must be 0
  P exp(int deg = -1) const {
    assert((*this)[0] == T(0));
    const int n = (int) this->size();
    if(deg == -1) deg = n;
    P ret({T(1)});
    for(int i = 1; i < deg; i <<= 1) {
      ret = (ret * (pre(i << 1) + T(1) - ret.log(i << 1))).pre(i << 1);
    }
    return ret.pre(deg);
  }

  P pow(int64_t k, int deg = -1) const {
    const int n = (int) this->size();
    if(deg == -1) deg = n;
    for(int i = 0; i < n; i++) {
      if((*this)[i] != T(0)) {
        T rev = T(1) / (*this)[i];
        P C(*this * rev);
        P D(n - i);
        for(int j = i; j < n; j++) D[j - i] = C[j];
        D = (D.log() * k).exp() * (*this)[i].pow(k);
        P E(deg);
        if(i * k > deg) return E;
        auto S = i * k;
        for(int j = 0; j + S < deg && j < D.size(); j++) E[j + S] = D[j];
        return E;
      }
    }
    return *this;
  }


  T eval(T x) const {
    T r = 0, w = 1;
    for(auto &v : *this) {
      r += w * v;
      w *= x;
    }
    return r;
  }
};

//aはbの何乗以下かを満たす数の内最大の物,(a,10)はaの桁数
ll expless(ll a,ll b){
  ll k=0;
  ll o=1;
  while(a>=o){
    k++;
    o=o*b;
  }
  return k;
}
//aをb進法で表す
ll base(ll a,ll b){
  ll ans=0;
  ll k;
 while(a>0){
    k=a%b;
    ans+=k;
    a=a/b;
 }
  return ans;
}
//b進法のaを10進法に直す
ll tenbase(ll a,ll b){
  ll c=expless(a,10);
  ll ans=0;
  ll k=1;
  for(int i=0;i<c;i++){
    ans+=(a%10)*k;
    k=k*b;
    a=a/10;
  }
  return ans;
}
vector<pair<long long, long long> > prime_factorize(long long N) {
    vector<pair<long long, long long> > res;
    for (long long a = 2; a * a <= N; ++a) {
        if (N % a != 0) continue;
        long long ex = 0; // 指数

        // 割れる限り割り続ける
        while (N % a == 0) {
            ++ex;
            N /= a;
        }

        // その結果を push
        res.push_back({a, ex});
    }

    // 最後に残った数について
    if (N != 1) res.push_back({N, 1});
    return res;
}
ll atll(ll a,ll b){
  b++;
  ll c=expless(a,10);
  ll d=c-b;
  ll f=1;
  for(int i=0;i<d;i++){
    f=f*10;
  }
  a=(a/f);
  return a%10;
}
//aがbで何回割り切るか
ll exp(ll a,ll b){
  ll ans=0;
  while(a%b==0){
    a=a/b;
    ans++;
  }
  return ans;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int X[6]={1,1,0,-1,-1,0};
const int Y[6]={0,1,1,0,-1,-1};

template<typename T>
vector<T> smallest_prime_factors(T n) {

    vector<T> spf(n + 1);
    for (int i = 0; i <= n; i++) spf[i] = i;


    for (T i = 2; i * i <= n; i++) {

        // 素数だったら
        if (spf[i] == i) {

            for (T j = i * i; j <= n; j += i) {

                // iを持つ整数かつまだ素数が決まっていないなら
                if (spf[j] == j) {
                    spf[j] = i;
                }
            }
        }
    }

    return spf;
}

vector<pair<ll,ll>> factolization(ll x, vector<ll> &spf) {
  vector<pair<ll,ll>> ret;
  ll p;
  ll z;
    while (x != 1) {
     p=(spf[x]);
      z=0;
      while(x%p==0){
        z++;
        x /= p;
      }
      ret.push_back({p, z});
    }
    return ret;
}
ll f(ll a,ll b){
  if(b!=0){
 return (a-b+1)*modPow(a+1,b-1,MOD)%MOD;
  }
  else{
    return 1;
  }
}
int main(){
COMinit();
 ll n,m;
  cin>>n>>m;
  string s;
  cin>>s;
 ll cnt=0;
  mint ans=0;
  ll count=0;
  mint tmp=0;
  vector<ll> xo;
  ll x=0;
  for(ll i=0;i<m;i++){
    if(s.at(i)=='o'){
      count=count+1;
    }
  }
  if(count==0){
    for(ll i=0;i<n-m+1;i++){
      tmp=0;
      tmp+=modPow(n,i+m,mod);
      if(n-m-i>=1){
                tmp-=m*f(n-1,i+m);
            }
      if(n-m-i>=2){
         for(ll j=0;j<=m-2;++j){
             tmp+=mint(mint((m-1-j)*f(n-2-j,i+m-j))*mint(f(j,j)*COM(m+i,j)));
           }
       }
       ans=ans+mint(mint((tmp)*(n-m+1))*modPow(n,n-m-i,mod));
     
  }
    cout<<ans<<endl;
  }
  else{
    for(int i=0;i<m;i++){
      if(s.at(i)=='o'){
        if(x!=0){
          xo.push_back(x);
        }
        x=0;
      }
      else{
        x++;
      }
    }
        ll l=(s[0]=='o'?0:xo[0]),r=x;
    if(s[0]!='o'){
      xo.erase(xo.begin());
    }
    tmp=tmp+1;

    for(int i=0;i<ll(xo.size());i++){

      tmp*=f(xo.at(i),xo.at(i));
      tmp/=fac[xo.at(i)];
      cnt+=xo.at(i);
    
    }
    ll tmp3;
    tmp*=fac[cnt];
     vector<ll> table(max(l+r-1,1LL),0);
for(int i=0;i<l;i++){
  for(int j=0;j<r;j++){
    table[i+j]+=((f(i,i)*f(j,j))%mod*COM(i+j,i))%mod;
    table[i+j]%=mod;
  }
}
   
//   cout<<tmp<<endl;
    mint s=0;
    for(int i=0;i<n-m+1;i++){
            mint tmp2=0;
            tmp2+=f(n-m+l+r,i+l+r);
 
            if(n-m-i>=1){
                for(int j=0;j<=l-1;j++){
                    tmp2-=mint(mint(f((n-m+l+r)-(1+j),(i+l+r)-j)*f(j,j))*COM(i+l+r,j));
                  
                }
                for(int j=0;j<=r-1;j++){
                    tmp2-=mint(mint(f((n-m+l+r)-(1+j),(i+l+r)-j)*f(j,j))*COM(i+l+r,j));
                 
                }
            }
     
             if(n-m-i>=2){
                for(int j=0;j<=l+r-2;j++){
                    tmp2+=mint(mint(f((n-m+l+r)-(2+j),(i+l+r)-j)*table[j])*COM(i+l+r,j));
                }
            }
      
            ans+=mint(mint(mint(mint(tmp*tmp2)*COM(i+l+r+cnt,cnt))*(n-m+1))*modPow(n,n-i-cnt-l-r,mod));
      s=tmp2;
   //   cout<<s<<endl;
        }
        cout<<ans<<endl;
   // cout<<l+r-2<<endl;
    }
}
0