結果

問題 No.1195 数え上げを愛したい（文字列編）
コンテスト
ユーザー carrot46
提出日時 2020-08-25 12:44:45
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 2,289 ms / 3,000 ms
コード長 5,867 bytes
コンパイル時間 2,084 ms
コンパイル使用メモリ 185,476 KB
実行使用メモリ 61,020 KB
最終ジャッジ日時 2024-11-06 11:13:17
合計ジャッジ時間 32,919 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 26
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
//#include <chrono>
//#pragma GCC optimize("Ofast")
using namespace std;
#define reps(i,s,n) for(int i = s; i < n; i++)
#define rep(i,n) reps(i,0,n)
#define Rreps(i,n,e) for(int i = n - 1; i >= e; --i)
#define Rrep(i,n) Rreps(i,n,0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;

ll N,M,H,W,Q,K,A,B;
string S;
typedef pair<ll, ll> P;
const ll INF = (1LL<<58);

template <long long mod> class mint{
    public:
        ll x;
        long long mod_plus;
        mint(){x = 0;}
        mint(ll _x){
            mod_plus = (LLONG_MAX / mod) * mod;
            x = (_x < 0 ? ((_x += mod_plus) < 0 ? _x + mod_plus : _x) : _x)%mod;
        }

        mint operator-(){
            return x == 0 ? 0 : mod - x;
        }
        mint& operator+=(const mint& a){
            if((x += a.x) >= mod) x -= mod;
            return *this;
        }
        mint operator+(const mint& a){
            mint res(*this);
            return res += a;
        }
        mint& operator-=(const mint& a){
            if((x -= a.x) < 0) x += mod;
            return *this;
        }
        mint operator-(const mint& a){
            mint res(*this);
            return res -= a;
        }
        mint& operator*=(const mint& a){
            (x *= a.x)%=mod;
            return *this;
        }
        mint operator*(const mint& a){
            mint res(*this);
            return res *= a;
        }
        mint pow(unsigned long long pw) const{
            mint res(1), comp(*this);
            while(pw){
                if(pw&1) res *= comp;
                comp *= comp;
                pw >>= 1;
            }
            return res;
        }
        //以下、modが素数のときのみ
        mint inv() const{
            mint res(*this);
            return res.pow(mod - 2);
        }
        mint& operator/=(const mint &a){
            (x *= a.inv().x)%=mod;
            return *this;
        }
        mint operator/(const mint &a) const{
            mint res(*this);
            return res /= a;
        }
};
//1000000009も素数

template <long long mod, int root> class NTT{
    using vm = vector<mint<mod> >;
    void make_root_pow(int n, vm &root_pow){
        root_pow.resize(n + 1);
        mint<mod> new_root = mint<mod>(root).pow((mod - 1) / n);
        root_pow[0].x = 1;
        rep(i,n){
            root_pow[i + 1] = root_pow[i] * new_root;
        }
    }
    void make_bit_reverse(int n, vector<int> &v){
        v.resize(n);
        rep(i,n) v[i] = i;
        for(int i = 1; (1<<i) <= n; ++i){
            int l = 1<<(i - 1), r = 1<<i;
            int plus = n >> i;
            for(int j = l; j < r; ++j){
                int temp = v[j - l] + plus;
                if(j < temp) swap(v[j], v[temp]);
            }
        }
    }
    void dft(int n, vm &f, bool inv, vm &root_pow, vector<int> &id){
        vm g(n);
        rep(i,n) g[i] = f[id[i]];
        swap(f, g);
        for(int l = n / 2, len = 1; l >= 1; l /= 2, len *= 2){
            for(int i = 0; i < n; i += len * 2){
                rep(j, len){
                    mint<mod> z = inv ? root_pow[n - l * j] : root_pow[l * j];
                    g[i + j] = f[i + j] + (z * f[i + len + j]);
                    g[i + len + j] = f[i + j] - (z * f[i + len + j]);
                }
            }
            swap(f, g);
        }
        if(inv) {
            mint<mod> n_inv = mint<mod>(n).inv();
            rep(i, n) f[i] *= n_inv;
        }
    }
public:
    NTT(){}
    vm convolution(vector<ll> &a, vector<ll> &b){
        int sz = a.size() + b.size() - 1, n = 1;
        while(sz > n) n *= 2;
        vm g(n, 0), h(n, 0), root_pow(n + 1, 1), gh(n);
        vector<int> id(n);
        rep(i, (int)a.size()) g[i] += mint<mod>(a[i]);
        rep(i, (int)b.size()) h[i] += mint<mod>(b[i]);
        make_root_pow(n, root_pow);
        make_bit_reverse(n, id);
        dft(n, g, false, root_pow, id);
        dft(n, h, false, root_pow, id);
        rep(i, n) gh[i] = g[i] * h[i];
        dft(n, gh, true, root_pow, id);
        gh.resize(sz);
        return gh;
    }
};
//(  998244353, 3  )と(  1224736769, 3  )がおすすめ

#define mod1 998244353
#define mod2 1224736769

//mod2つの場合
ll two_garner(mint<mod1> a, mint<mod2> b){
    b -= a.x;
    mint<mod2> mul = b * mint<mod2>(mod1).inv();
    return mul.x * mod1 + a.x;
}

//一般の場合
ll extgcd(ll a, ll b, ll &x, ll &y){
    ll d = a;
    if(b != 0){
        d = extgcd(b, a%b, y, x);
        y -= (a/b) * x;
    }else{
        x=1;
        y=0;
    }
    return d;
}
ll mod_inv(ll a, ll mod){
    ll x, y;
    if((a %= mod) < 0) a += mod;
    extgcd(mod, a, x, y);
    return y;
}
ll garner(vector<P> mr){
    int n = mr.size();
    ll res = 0, mul = 1;
    vec a(n);
    rep(i,n){
        a[i] = (mr[i].se - res) % mr[i].fi;
        if(a[i] < 0) a[i] += mr[i].fi;
        (a[i] *= mod_inv(mul, mr[i].fi))%=mr[i].fi;
        res += a[i] * mul;
        mul *= mr[i].fi;
    }
    return res;
}

using mint1 = mint<mod1>;
using vm = vector<mint1>;
const ll MAX_N = ll(3e+5) + 10;
vm fact(MAX_N, mint1(1)), fact_inv(MAX_N, mint1(1));
void makefact(){
    reps(i,2,MAX_N) {
        fact[i] = fact[i-1] * mint1(i);
        fact_inv[i] = fact[i].inv();
    }
}

int main() {
    makefact();
    cin>>S;
    N = S.size();
    vec num(26, 0);
    for(char c : S) ++num[c - 'a'];
    sort(ALL(num));
    NTT<mod1, 3> ntt;
    vec dp(1, 0), temp;
    dp[0] = 1;
    int sum = 0;
    rep(i, 26){
        sum += num[i];
        temp.resize(num[i] + 1);
        rep(j, num[i] + 1) temp[j] = fact_inv[j].x;
        vm res = ntt.convolution(dp, temp);
        dp.resize(sum + 1);
        rep(j, sum + 1) dp[j] = res[j].x;
    }
    mint1 ans(0);
    rep(i, N) ans += fact[i + 1] * dp[i + 1];
    cout<<ans.x<<endl;
}
0