結果

問題 No.2206 Popcount Sum 2
ユーザー nononnonon
提出日時 2024-05-05 19:02:57
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 685 ms / 4,000 ms
コード長 6,374 bytes
コンパイル時間 2,695 ms
コンパイル使用メモリ 219,708 KB
実行使用メモリ 14,236 KB
最終ジャッジ日時 2024-05-05 19:03:11
合計ジャッジ時間 12,822 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,376 KB
testcase_02 AC 183 ms
8,672 KB
testcase_03 AC 214 ms
8,540 KB
testcase_04 AC 197 ms
8,796 KB
testcase_05 AC 635 ms
14,104 KB
testcase_06 AC 685 ms
14,228 KB
testcase_07 AC 655 ms
14,236 KB
testcase_08 AC 672 ms
14,232 KB
testcase_09 AC 662 ms
14,236 KB
testcase_10 AC 351 ms
14,104 KB
testcase_11 AC 344 ms
14,044 KB
testcase_12 AC 383 ms
14,232 KB
testcase_13 AC 307 ms
14,100 KB
testcase_14 AC 308 ms
14,104 KB
testcase_15 AC 314 ms
14,104 KB
testcase_16 AC 208 ms
14,236 KB
testcase_17 AC 214 ms
14,232 KB
testcase_18 AC 210 ms
14,008 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
using namespace std;
template<long long mod_>
struct modint
{
    modint():value(0){}
    modint(long long v)
    {
        long long x=(long long)(v%m());
        if(x<0)x+=m();
        value=x;
    }
    static modint raw(long long v)
    {
        modint x;
        x.value=v;
        return x;
    }
    static constexpr long long mod()noexcept{return m();}
    long long val()const{return value;}
    modint& operator++()
    {
        value++;
        if(value==m())value=0;
        return *this;
    }
    modint& operator--()
    {
        if(value==0)value=m();
        value--;
        return *this;
    }
    modint operator++(int)
    {
        modint res=*this;
        ++*this;
        return res;
    }
    modint operator--(int)
    {
        modint res=*this;
        --*this;
        return res;
    }
    modint& operator+=(const modint& a)
    {
        value+=a.value;
        if(value>=m())value-=m();
        return *this;
    }
    modint& operator-=(const modint& a)
    {
        value-=a.value;
        if(value<0)value+=m();
        return *this;
    }
    modint& operator*=(const modint& a)
    {
        unsigned long long x=value;
        x*=a.value;
        x%=m();
        if(x<0)x+=m();
        value=x;
        return *this;
    }
    modint& operator/=(const modint& a)
    {
        return *this=(*this)*a.inv();
    }
    modint operator+()const{return *this;}
    modint operator-()const{return modint()-*this;}
    modint pow(long long n)const
    {
        modint x=*this,res=1;
        while(n)
        {
            if(n&1)res*=x;
            x*=x;
            n>>=1;
        }
        return res;
    }
    modint inv()const
    {
        long long a=value,b=m(),u=1,v=0;
        while(b)
        {
            long long t=a/b;
            a-=t*b;
            swap(a,b);
            u-=t*v;
            swap(u,v);
        }
        return modint(u);
    }
    friend modint operator+(const modint& a, const modint& b)
    {
        modint res=a;
        res+=b;
        return res;
    }
    friend modint operator-(const modint& a, const modint& b)
    {
        modint res=a;
        res-=b;
        return res;
    }
    friend modint operator*(const modint& a, const modint& b)
    {
        modint res=a;
        res*=b;
        return res;
    }
    friend modint operator/(const modint& a, const modint& b)
    {
        modint res=a;
        res/=b;
        return res;
    }
    friend bool operator==(const modint& a, const modint& b)
    {
        return a.value==b.value;
    }
    friend bool operator!=(const modint& a, const modint& b)
    {
        return a.value!=b.value;
    }
private:
    long long value;
    static constexpr long long m(){return mod_;}
};
template<typename mint>
struct combination
{
    combination(int n=0):inner_fac(1,1),inner_finv(1,1){init(n);}
    mint fac(int n)
    {
        init(n);
        return inner_fac[n];
    }
    mint finv(int n)
    {
        init(n);
        return inner_finv[n];
    }
    mint inv(int n)
    {
        if(n==0)return 0;
        init(n);
        return inner_fac[n-1]*inner_finv[n];
    }
    mint C(int n, int r)
    {
        if(r<0)return 0;
        if(n<0)
        {
            n=-n;
            mint res=C(n-1+r,r);
            if(r&1)res=-res;
            return res;
        }
        if(n<r)return 0;
        if(n<bound)
        {
            init(n);
            return inner_fac[n]*inner_finv[n-r]*inner_finv[r];
        }
        init(r);
        mint res=1;
        for(int i=0;i<r;i++)res*=(n-i);
        return res*inner_finv[r];
    }
    mint P(int n, int r)
    {
        if(n<0||r<0||n<r)return 0;
        if(n<bound)
        {
            init(n);
            return inner_fac[n]*inner_finv[n-r];
        }
        mint res=1;
        for(int i=0;i<r;i++)res*=(n-i);
        return res;
    }
    mint H(int n, int r)
    {
        return C(n-1+r,r);
    }
private:
    const int bound=1<<25;
    vector<mint>inner_fac,inner_finv;
    void init(int n)
    {
        int sz=inner_fac.size();
        if(sz>n)return;
        n=min(max(n,2*sz),bound);
        inner_fac.resize(n+1);
        inner_finv.resize(n+1);
        for(int i=sz;i<=n;i++)inner_fac[i]=inner_fac[i-1]*i;
        inner_finv[n]=inner_fac[n].inv();
        for(int i=n;i>sz;i--)inner_finv[i-1]=inner_finv[i]*i;
    }
};
struct Mo
{
    Mo(int _n, int _q):n(_n),q(_q){querys.reserve(_n);}
    void add(int l, int r){querys.emplace_back(l,r);}
    template<typename ExL,typename ShL,typename ExR,typename ShR,typename O>
    void build(const ExL&exl, const ShL&shl, const ExR&exr, const ShR&shr, const O&out)
    {
        const int b=n/min(n,(int)sqrt(n));
        vector<int>idx(q);
        for(int i=0;i<q;i++)idx[i]=i;
        sort(idx.begin(),idx.end(),[&](int i, int j)
        {
            auto[li,ri]=querys[i];
            auto[lj,rj]=querys[j];
            int bi=li/b,bj=lj/b;
            return bi==bj?bi&1?ri<rj:ri>rj:bi<bj;
        });
        int l=0,r=0;
        for(int i:idx)
        {
            auto[li,ri]=querys[i];
            while(l>li)exl(--l);
            while(r<ri)exr(r++);
            while(l<li)shl(l++);
            while(r>ri)shr(--r);
            out(i);
        }
    }
private:
    int n,q;
    vector<pair<int,int>>querys;
};
using mint=modint<998244353>;
combination<mint>C;
vector<mint>multipoint_binomial_sum(const vector<pair<int,int>>& qs)
{
    auto binom=[&](int n, int k){return C.C(n,k);};
    int n_max=2,q=qs.size();
    for(auto[n,k]:qs)n_max=max(n_max,n);
    Mo mo(n_max,q);
    for(auto[n,k]:qs)mo.add(k,n);
    vector<mint>res(q);
    int n=0,k=0;
    mint ans=1;
    const mint inv2=mint(2).inv();
    auto exl=[&](int i){ans-=binom(n,k--);};
    auto shl=[&](int i){ans+=binom(n,++k);};
    auto exr=[&](int i){ans+=ans-binom(n++,k);};
    auto shr=[&](int i){ans=(ans+binom(--n,k))*inv2;};
    auto out=[&](int i){res[i]=ans;};
    mo.build(exl,shl,exr,shr,out);
    return res;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int Q;
    cin>>Q;
    vector<pair<int,int>>qs(Q);
    for(auto&p:qs)
    {
        int n,k;
        cin>>n>>k;
        p=make_pair(n-1,k-1);
    }
    auto binom=multipoint_binomial_sum(qs);
    for(int i=0;i<Q;i++)
    {
        mint ans=mint(2).pow(qs[i].first+1)-1;
        ans*=binom[i];
        cout<<ans.val()<<'\n';
    }
}
0