#729654 (C++17) No.1875 Flip Cards

• 問題: No.1875 Flip Cards
• ユーザー: ytqm3
• 提出日時: 2022-01-10 18:04:31
• 言語: C++17 (gcc 13.3.0 + boost 1.87.0)
• 結果: AC
• 実行時間: 1,335 ms / 10,000 ms
• コード長: 6,794 bytes
• コンパイル時間: 5,325 ms
• コンパイル使用メモリ: 280,444 KB
• 最終ジャッジ日時: 2025-01-27 10:19:48
• ジャッジサーバーID （参考情報）: judge4 / judge1

ファイルパターン	結果
sample	AC * 3
other	AC * 7

コンパイルメッセージ

main.cpp: In function ‘int main()’:
main.cpp:324:8: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  324 |   scanf("%d%d",&N,&M);
      |   ~~~~~^~~~~~~~~~~~~~
main.cpp:329:10: warning: ignoring return value of ‘int scanf(const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  329 |     scanf("%d%d%d",&a,&b,&c);
      |     ~~~~~^~~~~~~~~~~~~~~~~~~

ソースコード

#include<bits/stdc++.h>
#include<atcoder/all>
typedef uint64_t u64;
typedef int64_t i64;
using namespace std;
template<u64 mod> using modint=atcoder::static_modint<mod>;

template<typename T> struct comb{
  vector<T> dat,idat;
  comb(int mx=3000000):dat(mx+1,1),idat(mx+1,1){
    for(int i=1;i<=mx;++i){
      dat[i]=dat[i-1]*i;
    }
    idat[mx]/=dat[mx];
    for(int i=mx;i>0;--i){
      idat[i-1]=idat[i]*i;
    }
  }
  T operator()(int n,int k){
    if(n<0||k<0||n<k){
      return 0;
    }
    return dat[n]*idat[k]*idat[n-k];
  }
};

template<u64 mod> struct FPS{
  typedef modint<mod> mint;
  vector<mint> val;
  FPS():val({0}){}
  FPS(mint t):val({t}){}
  FPS(int siz):val(max(1,siz)){}
  FPS(initializer_list<modint<mod>> init):val(init){}
  FPS(vector<mint> init):val(init){}
  mint &operator[](int i){
    return val[i];
  }
  int size(){
    return val.size();
  }
  void resize(int siz){
    val.resize(siz);
  }
  FPS& resize_(int siz){
    auto tmp=val;
    tmp.resize(siz);
    return (*this)=tmp;
  }
  FPS operator-(){
    for(mint& v:val){
      v=mint(0)-v;
    }
    return (*this);
  }
  FPS& operator+=(mint rhs){
    val[0]+=rhs;
    return (*this);
  }
  FPS& operator-=(mint rhs){
    val[0]-=rhs;
    return (*this);
  }
  FPS& operator*=(mint rhs){
    for(auto& v:val){
      v*=rhs;
    }
    return (*this);
  }
  FPS& operator/=(mint rhs){
    for(auto& v:val){
      v/=rhs;
    }
    return (*this);
  }
  FPS operator+(mint rhs){
    return FPS(*this)+=rhs;
  }
  FPS operator-(mint rhs){
    return FPS(*this)-=rhs;
  }
  FPS operator*(mint rhs){
    return FPS(*this)*=rhs;
  }
  FPS operator/(mint rhs){
    return FPS(*this)/=rhs;
  }
  FPS& operator+=(FPS rhs){
    resize(max(this->size(),rhs.size()));
    for(int i=0;i<int(rhs.size());++i){
      (*this)[i]+=rhs[i];
    }
    return (*this);
  }
  FPS& operator-=(FPS rhs){
    resize(max(this->size(),rhs.size()));
    for(int i=0;i<int(rhs.size());++i){
      (*this)[i]-=rhs[i];
    }
    return (*this);
  }
  FPS& operator*=(FPS rhs){
    val=atcoder::convolution(val,rhs.val);
    return (*this);
  }
  FPS& operator/=(FPS rhs){
    return (*this)*=rhs.inv();
  }
  FPS& operator>>=(int k){
    if(int(val.size())<=k){
      return (*this)={0};
    }
    FPS res=val;
    res.val.erase(res.val.begin(),res.val.begin()+k);
    return (*this)=res;
  }
  FPS& operator<<=(int k){
    FPS res=val;
    res.val.insert(res.val.begin(),k,mint(0));
    return (*this)=res;
  }
  FPS operator+(FPS rhs){
    return FPS(*this)+=rhs;
  }
  FPS operator-(FPS rhs){
    return FPS(*this)-=rhs;
  }
  FPS operator*(FPS rhs){
    return FPS(*this)*=rhs;
  }
  FPS operator/(FPS rhs){
    return FPS(*this)/=rhs;
  }
  FPS operator<<(int k){
    return FPS(*this)<<=k;
  }
  FPS operator>>(int k){
    return FPS(*this)>>=k;
  }
  FPS shrink(){
    for(int i=val.size()-1;i>0;--i){
      if(val[i]==0){
        val.pop_back();
      }
      else{
        break;
      }
    }
    return (*this);
  }
  FPS diff_(){
    if(val.size()==1){
      return (*this)={0};
    }
    FPS f(val.size()-1);
    for(size_t i=1;i<val.size();++i){
      f[i-1]=val[i]*i;
    }
    return f;
  }
  FPS integral_(){
    FPS f(val.size()+1);
    for(size_t i=0;i<val.size();++i){
      f[i+1]=val[i]/(i+1);
    }
    return f;
  }
  FPS inv_(int mx=-1){
    if(mx==-1){
      mx=val.size();
    }
    if(val[0]==0){
      assert(0);
    }
    FPS g({mint(1)/val[0]});
    int now=1;
    while(now<mx){
      now<<=1;
      FPS t=(*this);
      t.resize(now);
      t*=g;
      t=-t+mint(2);
      g*=t;
      g.resize(now);
    }
    g.resize(mx);
    return g;
  }
  FPS exp_(int mx=-1){
    if(mx==-1){
      mx=val.size();
    }
    if(val[0]!=0){
      assert(0);
    }
    FPS g(mint(1));
    int now=1;
    while(now<mx){
      now<<=1;
      FPS t=(*this);
      t.resize(now);
      g*=t-g.log_(now)+mint(1);
      g.resize(now);
    }
    g.resize(mx);
    return g;
  }
  FPS log_(int mx=-1){
    if(mx==-1){
      mx=val.size();
    }
    if(val[0]!=1){
      assert(0);
    }
    auto f=(*this);
    f.resize(mx);
    return (f.diff_()/f).integral_().resize_(mx);
  }
  FPS pow_(i64 k,int mx=-1){
    if(mx==-1){
      mx=val.size();
    }
    i64 t=0;
    for(auto v:val){
      if(v==0){
        t++;
      }
      else{
        break;
      }
    }
    auto f=(*this)>>t;
    if(f[0]==0){
      f={0},f.resize(mx);
      return f;
    }
    mint c=f[0];
    f/=c;
    (f.log(mx)*=mint(k)).exp(mx)*=c.pow(k);
    if(t*k<=mx){
      f<<=t*k;
      f.resize(mx);
      return f;
    }
    else{
      f={0},f.resize(mx);
      return f;
    }
  }
  FPS& diff(){
    return (*this)=diff_();
  }
  FPS& integral(){
    return (*this)=integral_();
  }
  FPS& inv(int mx=-1){
    return (*this)=inv_(mx);
  }
  FPS& exp(int mx=-1){
    return (*this)=exp_(mx);
  }
  FPS& log(int mx=-1){
    return (*this)=log_(mx);
  }
  FPS& pow(i64 k,int mx=-1){
    return (*this)=pow_(k,mx);
  }
  void taylor_shift(mint c){
    comb<mint> C(val.size());
    vector<mint> g(val.size());
    mint now=1;
    for(size_t i=0;i<val.size();++i){
      val[i]*=C.dat[i];
      g[i]=now*C.idat[i];
      now*=c;
    }
    reverse(val.begin(),val.end());
    g=atcoder::convolution(val,g);
    g.resize(val.size());
    reverse(g.begin(),g.end());
    for(size_t i=0;i<val.size();++i){
      g[i]*=C.idat[i];
    }
    val=g;
  }
};

template<u64 mod> FPS<mod> product(vector<FPS<mod>> a){
  int siz=1;
  while(siz<int(a.size())){
    siz<<=1;
  }
  vector<FPS<mod>> res(siz*2-1,{1});
  for(int i=0;i<int(a.size());++i){
    res[i+siz-1]=a[i];
  }
  for(int i=siz-2;i>=0;--i){
    res[i]=res[2*i+1]*res[2*i+2];
  }
  return res[0];
}

template<u64 mod> FPS<mod> inv_sum(int M,vector<FPS<mod>> f,vector<FPS<mod>> g){
  int siz=1;
  while(siz<int(f.size())){
    siz<<=1;
  }
  vector<FPS<mod>> mol(siz*2-1),den(siz*2-1,{1});
  for(size_t i=0;i<f.size();++i){
    mol[i+siz-1]=f[i];
    den[i+siz-1]=g[i];
  }
  for(int i=siz-2;i>=0;--i){
    den[i]=den[2*i+1]*den[2*i+2];
    mol[i]=mol[2*i+1]*den[2*i+2]+mol[2*i+2]*den[2*i+1];
  }
  mol[0]*=den[0].inv(M+1);
  return mol[0].resize_(M+1);
}

int main(){
  constexpr u64 mod=998244353;
  typedef modint<mod> mint;
  int N,M;
  scanf("%d%d",&N,&M);
  mint prod=1;
  vector<FPS<mod>> f(N,1),g(N,2);
  for(int i=0;i<N;++i){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    prod*=mint(a).pow(c);
    mint t=mint(b)/a;
    f[i][0]=t*c;
    g[i][0]=1,g[i][1]=t;
  }
  auto h=inv_sum(M,f,g);
  h.integral();
  h.resize(M+1);
  h.exp();
  h.taylor_shift(-1);
  f.resize(M+1,1),g.resize(M+1,2);
  for(int i=0;i<=M;++i){
    f[i][0]=h[i];
    g[i][0]=1,g[i][1]=-i;
  }
  h=inv_sum(M,f,g);
  for(int i=0;i<=M;++i){
    h[i]*=prod;
  }
  for(int i=1;i<=M;++i){
    printf("%d\n",int(h[i].val()));
  }
}