結果

問題 No.2237 Xor Sum Hoge
ユーザー momoyuumomoyuu
提出日時 2023-10-24 10:26:35
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 530 ms / 10,000 ms
コード長 4,490 bytes
コンパイル時間 2,703 ms
コンパイル使用メモリ 151,444 KB
実行使用メモリ 6,988 KB
最終ジャッジ日時 2023-10-24 10:26:59
合計ジャッジ時間 13,415 ms
ジャッジサーバーID
（参考情報） 		judge11 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 501 ms
6,988 KB
testcase_01 AC 21 ms
4,732 KB
testcase_02 AC 21 ms
4,728 KB
testcase_03 AC 21 ms
4,732 KB
testcase_04 AC 21 ms
4,732 KB
testcase_05 AC 21 ms
4,748 KB
testcase_06 AC 21 ms
4,732 KB
testcase_07 AC 21 ms
4,732 KB
testcase_08 AC 21 ms
4,744 KB
testcase_09 AC 21 ms
4,744 KB
testcase_10 AC 21 ms
4,748 KB
testcase_11 AC 117 ms
5,052 KB
testcase_12 AC 231 ms
5,612 KB
testcase_13 AC 473 ms
6,832 KB
testcase_14 AC 250 ms
5,656 KB
testcase_15 AC 127 ms
5,088 KB
testcase_16 AC 450 ms
6,584 KB
testcase_17 AC 450 ms
6,460 KB
testcase_18 AC 221 ms
5,420 KB
testcase_19 AC 219 ms
5,384 KB
testcase_20 AC 459 ms
6,468 KB
testcase_21 AC 475 ms
6,864 KB
testcase_22 AC 467 ms
6,824 KB
testcase_23 AC 530 ms
6,976 KB
testcase_24 AC 498 ms
6,972 KB
testcase_25 AC 469 ms
6,824 KB
testcase_26 AC 498 ms
6,864 KB
testcase_27 AC 475 ms
6,872 KB
testcase_28 AC 474 ms
6,848 KB
testcase_29 AC 487 ms
6,824 KB
testcase_30 AC 500 ms
6,984 KB
testcase_31 AC 20 ms
4,708 KB
testcase_32 AC 21 ms
4,712 KB
testcase_33 AC 21 ms
4,748 KB
testcase_34 AC 20 ms
4,708 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<iostream>
#include<algorithm>
#include<stack>
#include<vector>
#include<set>
#include<string>
#include<cstdint>

using namespace std;
using ll = long long;

#include<atcoder/modint>
#include<atcoder/convolution>
using mint = atcoder::modint998244353;
#define conv(a,b) atcoder::convolution(a,b)
ostream& operator<<(ostream& os, const mint& m){
    os << m.val();
    return os;
}

template < typename mint >
struct FPS:vector<mint>{
    FPS(){}
    FPS(int n){
        this->resize(n);
    }
    FPS(vector<mint>a){
        *this = a;
    }
    FPS &operator+=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] += r[i];
        return *this;
    }
    FPS &operator+=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] += r;
        return *this;
    }
    FPS &operator-=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] -= r[i];
        return *this;
    }
    FPS &operator-=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] -= r;
        return *this;
    }
    FPS &operator*=(const FPS&r){
        vector<mint> nxt = conv(*this,r);
        this->resize(nxt.size());
        for(int i = 0;i<nxt.size();i++) (*this)[i] = nxt[i];
        return *this;
    }
    FPS &operator*=(const mint&r){
        for(int i = 0;i<(int)this->size();i++) (*this)[i] *= r;
        return *this;
    }
    FPS operator+(const FPS&r) const {return FPS(*this)+=r;}
    FPS operator+(const mint&r) const {return FPS(*this)+=r;}
    FPS operator-(const FPS&r) const {return FPS(*this)-=r;}
    FPS operator-(const mint&r) const {return FPS(*this)-=r;}
    FPS operator*(const FPS&r) const {return FPS(*this)*=r;}

    void print(){
        for(int i = 0;i<(int)this->size();i++){
            if(i) cout<<" ";
            cout<<(*this)[i];
        }
        cout<<endl;
    }

    int deg(){return (int)this->size()-1;}

    // f^-1 mod x^n
    FPS<mint> inv(int n){
        assert((*this)[0].val()!=0);
        FPS<mint> g(1);
        g[0] = 1/(*this)[0];
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 2;
        while(now<n){
            g = g * (tmp-g*(*this));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        g.resize(n);
        return g;
    }

    FPS<mint> diff(){
        FPS<mint>g(this->size()-1);
        for(int i = 0;i+1<this->size();i++) g[i] = mint(i+1) * (*this)[i+1];
        return g;
    }

    FPS<mint> integral(){
        FPS<mint>g(this->size()+1);
        g[0] = 0;
        for(int i = 1;i<=this->size();i++) g[i] = (*this)[i-1] / mint(i);
        return g;
    }

    FPS<mint> log(int n){
        assert((*this)[0].val()==1);
        return ((*this).diff() * (*this).inv(n-1)).integral();
    }

    FPS<mint> exp(int n){
        assert((*this)[0].val()==0);
        FPS<mint> g(1);
        g[0] = 1;
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 1;
        while(now<n){
            g = g * ((*this) + tmp - g.log(now<<1));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        return g;
    }
    
};

template < typename mint >
FPS<mint> pow(FPS<mint>&a,ll k,int n){
    FPS<mint> ans(n+1);
    ans[0] += 1;
    FPS<mint> tmp = a;
    tmp.resize(n+1);
    while(k){
        if(k&1){
            ans *= tmp;
            ans.resize(n+1);
        }
        tmp *= tmp;
        tmp.resize(n+1);
        k>>=1;
    }
    return ans;
}

mint fac[1<<17],ifac[1<<17];
int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    
    ll n,b,c;
    cin>>n>>b>>c;

    fac[0] = 1;
    for(int i = 1;i<1<<17;i++) fac[i] = fac[i-1] * i;
    for(int i = 0;i<1<<17;i++) ifac[i] = fac[i].inv();
    FPS<mint> f(n+1),g(n+1);
    FPS<mint> now(1);
    now[0] = 1;
    for(int i = 0;i<=n;i++){
        if(i%2==0) f[i] += fac[n] * ifac[i] * ifac[n-i];
        else g[i] += fac[n] * ifac[i] * ifac[n-i];
    }

    for(int i = 0;i<=60;i++){
        FPS<mint> nxt;
        if(c&1) nxt = now * g;
        else nxt =  now * f;
        now = FPS<mint>(1);
        for(int j = 0;j<nxt.size();j++){
            if(j>b) break;
            if(j%2==b%2){
                int want = j >> 1;
                if(want>=now.size()) now.resize(want+1);
                now[want] += nxt[j];
            }
        }
        c >>= 1;
        b >>= 1;
    }
    cout<<now[0].val()<<endl;
}
0