#839516 (C++17) No.2215 Slide Subset Sum

提出ソース
結果

問題	No.2215 Slide Subset Sum
ユーザー	cureskol
提出日時	2023-02-11 11:54:36
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	TLE
実行時間	-
コード長	13,176 bytes
コンパイル時間	4,064 ms
コンパイル使用メモリ	273,336 KB
実行使用メモリ	11,164 KB
最終ジャッジ日時	2024-07-08 02:06:23
合計ジャッジ時間	9,905 ms
ジャッジサーバーID （参考情報）	judge5 / judge2
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	208 ms 6,816 KB
testcase_01	AC	303 ms 6,812 KB
testcase_02	TLE	-
testcase_03	--	-
testcase_04	--	-
testcase_05	--	-
testcase_06	--	-
testcase_07	--	-
testcase_08	--	-
testcase_09	--	-
testcase_10	--	-
testcase_11	--	-
testcase_12	--	-
testcase_13	--	-
testcase_14	--	-
testcase_15	--	-
testcase_16	--	-
testcase_17	--	-
testcase_18	--	-
testcase_19	--	-
testcase_20	--	-
testcase_21	--	-
testcase_22	--	-
testcase_23	--	-
testcase_24	--	-
testcase_25	--	-
testcase_26	--	-
testcase_27	--	-
testcase_28	--	-
testcase_29	--	-
testcase_30	--	-
testcase_31	--	-
testcase_32	--	-
testcase_33	--	-
testcase_34	--	-
testcase_35	--	-
testcase_36	--	-
testcase_37	--	-
testcase_38	--	-
testcase_39	--	-
testcase_40	--	-
testcase_41	--	-
testcase_42	--	-
testcase_43	--	-
testcase_44	--	-
testcase_45	--	-
testcase_46	--	-
権限があれば一括ダウンロードができます
ソースコード

raw source code
#pragma region template
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
 
using ll=long long;
using ld=long double;
using vi=vector<int>;
using vll=vector<ll>;
using pi=pair<int,int>;
using pll=pair<ll,ll>;
 
#define overload2(a,b,c,...) c
#define overload3(a,b,c,d,...) d
#define overload4(a,b,c,d,e,...) e
#define overload5(a,b,c,d,e,f,...) f
 
#define TYPE1(T) template<typename T>
#define TYPE2(T,U) template<typename T,typename U>
#define TYPE(...) overload2(__VA_ARGS__,TYPE2,TYPE1)(__VA_ARGS__)
#define TYPES1(T) template<typename... T>
#define TYPES2(H,T) template<typename H,typename... T>
#define TYPES(...) overload2(__VA_ARGS__,TYPES2,TYPES1)(__VA_ARGS__)
 
#define REP4(i,s,n,d) for(int i=(s);i<(n);i+=(d))
#define REP3(i,s,n) REP4(i,s,n,1)
#define REP2(i,n) REP3(i,0,n)
#define REP1(n) REP2(tomato,n)
#define REP(...) overload4(__VA_ARGS__,REP4,REP3,REP2,REP1)(__VA_ARGS__)
 
#define RREP4(i,n,s,d) for(int i=(n)-1;i>=(s);i-=(d))
#define RREP3(i,n,s) RREP4(i,n,s,1)
#define RREP2(i,n) RREP3(i,n,0)
#define RREP1(n) RREP2(tomato,n)
#define RREP(...) overload4(__VA_ARGS__,RREP4,RREP3,RREP2,RREP1)(__VA_ARGS__)

#define FOR4(a,b,c,d,v) for(auto [a,b,c,d]:v)
#define FOR3(a,b,c,v) for(auto [a,b,c]:v)
#define FOR2(a,b,v) for(auto [a,b]:v)
#define FOR1(a,v) for(auto a:v)
#define FOR(...) overload5(__VA_ARGS__,FOR4,FOR3,FOR2,FOR1)(__VA_ARGS__)

#define AFOR4(a,b,c,d,v) for(auto&[a,b,c,d]:v)
#define AFOR3(a,b,c,v) for(auto&[a,b,c]:v)
#define AFOR2(a,b,v) for(auto&[a,b]:v)
#define AFOR1(a,v) for(auto&a:v)
#define AFOR(...) overload5(__VA_ARGS__,AFOR4,AFOR3,AFOR2,AFOR1)(__VA_ARGS__)

#define CFOR4(a,b,c,d,v) for(const auto&[a,b,c,d]:v)
#define CFOR3(a,b,c,v) for(const auto&[a,b,c]:v)
#define CFOR2(a,b,v) for(const auto&[a,b]:v)
#define CFOR1(a,v) for(const auto&a:v)
#define CFOR(...) overload5(__VA_ARGS__,CFOR4,CFOR3,CFOR2,CFOR1)(__VA_ARGS__)
 
#define ALL(v) v.begin(),v.end()
#define RALL(v) v.rbegin(),v.rend()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort(RALL(v))
#define REVERSE(v) reverse(ALL(v))
#define UNIQUE(v) SORT(v),v.erase(unique(ALL(v)),v.end())
#define SZ(v) int(v.size())
 
TYPES(T) void input(T&... a){ (cin>>...>>a); }
#define DECLARE(T,...) T __VA_ARGS__;input(__VA_ARGS__);
#define INT(...) DECLARE(int,__VA_ARGS__)
#define STR(...) DECLARE(string,__VA_ARGS__)
#define LL(...) DECLARE(long long,__VA_ARGS__)
#define CHR(...) DECLARE(char,__VA_ARGS__)
#define DBL(...) DECLARE(double,__VA_ARGS__)
#define VI(n,v) vi v(n);cin>>v;
#define VLL(n,v) vll v(n);cin>>v;
 
TYPE(T) istream&operator>>(istream&is,vector<T>&v){
  for(auto&a:v)cin>>a;
  return is;
}
TYPE(T) ostream&operator<<(ostream&os,const vector<T>&v){
  if(&os==&cerr)os<<"[";
  REP(i,v.size()){
    os<<v[i];
    if(i+1<v.size())os<<(&os==&cerr?",":" ");
  }
  if(&os==&cerr)os<<"]";
  return os;
}
TYPE(T,S) istream&operator>>(istream&is,pair<T,S>&p){
  cin>>p.first>>p.second;
  return is;
}

#ifdef __DEBUG
 #include <debug>
#else
 #define debug(...) void(0)
#endif

void print(){ cout << '\n'; }
TYPES(T,Ts) void print(const T& a,const Ts&... b){
  cout<<a;
  (cout<<...<<(cout<< ' ',b));
  cout << '\n';
}
 
TYPE(T) using pq=priority_queue<T>;
TYPE(T) using pqg=priority_queue<T,vector<T>,greater<T>>;
TYPE(T) T pick(queue<T>& que){assert(que.size()); T a=que.front();que.pop();return a;}
TYPE(T) T pick(pq<T>& que){assert(que.size()); T a=que.top();que.pop();return a;}
TYPE(T) T pick(pqg<T>& que){assert(que.size()); T a=que.top();que.pop();return a;}
TYPE(T) T pick(stack<T>& sta){assert(sta.size()); T a=sta.top();sta.pop();return a;}
 
string YES(bool f=true){return (f?"YES":"NO");}
string Yes(bool f=true){return (f?"Yes":"No");}
string yes(bool f=true){return (f?"yes":"no");}
 
constexpr int INF=1e9+7;
constexpr ll LINF=ll(1e18)+7;
constexpr ld EPS=1e-10;
 
vi iota(int n){vi a(n);iota(ALL(a),0);return a;}
TYPE(T) vector<pair<T,int>> query_sort(const vector<T>&v){
  vector<pair<T,int>> res(v.size());
  REP(i,v.size())res[i]={v[i],i};
  SORT(res);
  return res;
}
TYPE(T) T rev(T a){ REVERSE(a);return a; }
TYPE(T) void fin(T a){cout<<a<<'\n';exit(0);}
TYPE(T) bool chmax(T &a,T b){return (a<b&&(a=b,true));}
TYPE(T) bool chmin(T &a,T b){return (a>b&&(a=b,true));}
TYPES(T,Ns) auto make_vector(T x,int n,Ns ...ns){
  if constexpr(sizeof...(ns)==0)return vector<T>(n,x);
  else return vector(n,make_vector<T>(x,ns...));
}
bool in(const ll S,const int a){return (S>>a)&1;}
int popcount(const ll S){return __builtin_popcountll(S);}
int digit(char c){ return (c>='0' and c<='9' ? c-'0' : -1);}
ll sqrtll(ll a){ 
  for(ll b=sqrt(a);b*b<=a;b++)if(b*b==a)return b;
  for(ll b=sqrt(a);b>=0 and b*b>=a;b--)if(b*b==a)return b;
  return -1;
}
#pragma endregion template

#include <atcoder/modint>
#include <atcoder/convolution>
using namespace atcoder;
using mint=modint998244353;
namespace atcoder{
  ostream& operator<<(ostream &os,mint a){os<<a.val();return os;}
  istream& operator>>(istream &is,mint &a){
    long long b;is>>b;a=b;
    return is;
  }
}

#define REP_(i,n) for(int i=0;i<(n);i++)
template<typename T,int MX>
struct FormalPowerSeries:vector<T>{
  using FPS=FormalPowerSeries;
  using vector<T>::resize;
  using vector<T>::size;
  using vector<T>::at;
  using vector<T>::assign;
  using vector<T>::vector;
  using vector<T>::begin;
  using vector<T>::end;
  using vector<T>::back;
  using vector<T>::pop_back;
  using value_type=T;

  void strict(int n){ if(size()>n)resize(n); }
  void shrink(){ while(size() and back()==0)pop_back(); }

  FormalPowerSeries(const vector<T>&f){
    int n=min(MX,int(f.size()));
    resize(n);
    REP_(i,n)at(i)=f[i];
    shrink();
  }

  static FPS unit(){ return {1}; }
  static FPS x(){ return {0,1}; }
#pragma region operator
  FPS operator-()const{
    FPS g=*this;
    for(T&a:g)a=-a;
    return g;
  }
  
  FPS &operator+=(const FPS&g){
    if(size()<g.size())resize(g.size());
    REP_(i,g.size())at(i)+=g[i];
    return *this;
  }
  FPS operator+(const FPS &g)const{return FPS(*this)+=g;}

  FPS &operator+=(const T &a){
    if(!size())resize(1);
    at(0)+=a;
    return *this;
  }
  FPS operator+(const T& a)const{return FPS(*this)+=a;}
  friend FPS operator+(const T&a,const FPS&f){return f+a;}

  FPS &operator-=(const FPS &g){
    if(size()<g.size())resize(g.size());
    REP_(i,g.size())at(i)-=g[i];
    return *this;
  }
  FPS operator-(const FPS &g)const{return FPS(*this)-=g;}

  FPS &operator-=(const T &a){
    if(!size())resize(1);
    at(0)-=a;
    return *this;
  }
  FPS operator-(const T& a){return FPS(*this)-=a;}
  friend FPS operator-(const T&a,const FPS&f){return a+(-f);}
  
  FPS operator*(const FPS&g)const{ return FPS(convolution(*this,g)); }
  FPS&operator*=(const FPS&g){ return (*this)=(*this)*g; }

  FPS&operator*=(const T &a){
    REP_(i,size())at(i)*=a;
    return *this;
  }
  FPS operator*(const T &a)const{ return FPS(*this)*=a; }
  friend FPS operator*(const T&a,const FPS&f){return f*a;}

  FPS operator/(const FPS g)const{ return (*this)*g.inv(); }
  FPS&operator/=(const FPS&g){ return (*this)=(*this)/g; }

  FPS&operator/=(const T &a){ return *this *= a.inv(); }
  FPS operator/(const T &a){ return  FPS(*this)/=a; }

  FPS&operator<<=(const int d){
    if(d>=MX)return *this=FPS(0);
    resize(min(MX,int(size())+d));
    for(int i=int(size())-1-d;i>=0;i--)
      at(i+d)=at(i);
    for(int i=d-1;i>=0;i--)at(i)=0;
    return *this;
  }
  FPS operator<<(const int d)const{ return FPS(*this)<<=d; }
  FPS&operator>>=(const int d){
    if(d>=size())return *this=FPS(0);
    for(int i=d;i<size();i++)
      at(i-d)=at(i);
    strict(int(size())-d);
    return *this;
  }
  FPS operator>>(const int d)const{ return FPS(*this)>>=d; }
#pragma endregion operator

  FPS pre(int n)const{
    if(size()<=n)return *this;
    return FPS(begin(),begin()+n);
  }

  FPS inv(int SZ=MX)const{
    assert(size() and at(0)!=0);
    FPS res(1,at(0).inv());
    for(int n=0;(1<<n)<SZ;n++){
      res *= (2- (res*pre(1<<(n+1))).pre(1<<(n+1)));
      res.strict(1<<(n+1));
    }
    return res.pre(SZ);
  }

  FPS pow(long long n)const{
    assert(n>=0);
    if(n==0)return unit();
    if(n==1)return *this;

    FPS now=*this;
    now.shrink();
    if(!now.size())return now;
    int d;
    for(d=0;d<now.size() and now[d]==0;d++){}
    if(d>=(MX+n-1)/n)return FPS(0);
    now >>= d;
    d *= n;
    if(at(0)==1)return exp(n*log(now))<<d;
    FPS res=unit();
    while(n){
      if(n&1)res*=now;
      now*=now;
      n>>=1;
    }
    return res<<d;
  }

  FPS separate(int n){
    if(size()<=n)return FPS(0);
    FPS f_2(size()-n);
    for(int i=n;i<size();i++)f_2[i-n]=at(i);
    strict(n);
    return f_2;
  }

  FPS operator()(FPS g)const{
    assert(!g.size() or g[0]==0); // 自身が多項式なら g[0]!=0 でも良い
    if(size()==0)return *this;
    if(size()==1)return FPS(1,at(0));
    if(size()==2)return FPS(at(0)+at(1)*g);

    int m=sqrt(MX/20);
    FPS&g1=g;
    FPS g2=g1.separate(m);

    int z;
    for(z=1;z<g1.size() and g1[z]==0;z++){}
    if(z==g1.size()){
      FPS res(0),
          g2pow=FPS::unit();
      for(int i=0;i*m<MX and i<size();i++,g2pow*=g2)
        res += at(i) * g2pow<<(i*m);
      return res;
    }
    
    auto rec=[&](auto rec,int l,int d){
      if(d==0 or l>=size())return FPS(0);
      if(d==1)return FPS(1,at(l));
      if(d==2)return at(l) + (l+1<size()?at(l+1)*g1:FPS(0));
      FPS f1=rec(rec,l,d>>1);
      FPS f2=rec(rec,l+(d>>1),d-(d>>1));
      f2 *= g1.pow(d>>1);
      return f1+f2;
    };
    FPS res = rec(rec,0,size());

    FPS dfg=res,
        g1inv=(differential(g)>>(--z)).inv(),
        g2pow=FPS::unit();
    T factinv=1;
    
    for(int i=1;i*m<MX;i++){
      dfg=(differential(dfg)>>z)*g1inv;
      dfg.strict(MX-m*i);
      (g2pow*=g2).strict(MX-m*i);
      factinv /= i;
      res += factinv * (dfg * g2pow) << (m*i);
    }
    return res;
  }
  T operator()(T a)const{
    T res=0,b=1;
    for(int i=0;i<size();i++,b*=a)
      res += at(i)*b;
    return res;
  }

  void taylor_shift(T c){
    shrink();
    if(size()<=1 or c==0)return;
    int n=size();
    T fact=1;
    REP_(i,n){
      if(i)fact*=i;
      at(i)*=fact;
    }
    reverse(begin(),end());
    *this *= exp(c).pre(n);
    strict(n);
    reverse(begin(),end());
    T finv=fact.inv();
    for(int i=n-1;i>=0;i--){
      at(i)*=finv;
      finv *= i;
    }
  }

  static FPS differential(FPS f){
    if(f.size()<=1)return FPS(0);
    REP_(i,f.size()-1)f[i]=(i+1)*f[i+1];
    f.resize(f.size()-1);
    return f;
  }
  static FPS integral(FPS f){
    if(f.size()<MX)f.resize(f.size()+1);
    for(int i=f.size()-1;i>0;i--)f[i]=f[i-1]/i;
    f[0]=0;
    return f;
  }

  static FPS log(const FPS&f){
    assert(f.size() and f[0]==1);
    return integral(differential(f)/f);
  }
  static FPS exp(const FPS f){
    if(!f.size())return unit();
    assert(f[0]==0);
    FPS res=unit();
    for(int n=0;(1<<n)<MX;n++){
      res *= (f.pre(1<<(n+1))+1-log(res).pre(1<<(n+1)));
      res.strict(1<<(n+1));
    }
    return res;
  }
  static FPS exp(const T n){
    if(n==0)return unit();
    FPS res(MX,1);
    for(int i=1;i<MX;i++)res[i]=res[i-1]*n/i;
    return res;
  }
};
#undef REP_
using FPS = FormalPowerSeries<mint,201>;

int k;

template<typename X,bool COMMUTE=true>
struct GroupMultiply{
  using value_type = X;
  static constexpr X op(const X &x, const X &y) noexcept {
    //return x * y; 
    X z = x * y;
    for(int i=k;i<z.size();i++)z[i-k]+=z[i];
    z.strict(k);
    return z;
  }
  static constexpr void Rchop(X&x, const X&y){ 
    //x*=y; 
    x = op(x,y);
  }
  static constexpr void Lchop(const X&x, X&y){ 
    //if constexpr(COMMUTE){ y*=x; }
    //else{ y=x*y;} 
    y = op(x,y);
  }
  //static constexpr X inverse(const X &x) noexcept { return X(1)/x; }
  //static constexpr X power(const X &x, long long n) noexcept { return x.pow(n); }
  static constexpr X unit() { 
    // return X(1);
    return X{1}; 
  }
  static constexpr bool commute = COMMUTE;
};

template<typename Monoid>
class SWAG{
  using X=typename Monoid::value_type;

  stack<X> back_stack,front_stack; // back は後ろの各要素 front は前の累積和
  X back_value;

  inline X front_value()const{
    return front_stack.size()?front_stack.top():Monoid::unit();
  }
public:
  SWAG():back_value(Monoid::unit()){}
  void push_back(X x){
    back_stack.push(x);
    Monoid::Rchop(back_value,x);
  }
  void push_front(X x){
    front_stack.push(Monoid::op(x,front_value()));
  }
  void pop_front(){
    if(front_stack.empty()){
      if(back_stack.empty())return;
      while(back_stack.size()){
        push_front(back_stack.top());
        back_stack.pop();
      }
      back_value=Monoid::unit();
    }
    front_stack.pop();
  }
  X prod(){
    return Monoid::op(front_value(),back_value);
  }
  int size(){
    return back_stack.size()+front_stack.size();
  }
};

int main(){
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  INT(n,m);
  cin>>k;
  VI(n,v);
  
  SWAG<GroupMultiply<FPS,true>> swag;
  REP(i,n){
    debug(i);
    FPS f(k,0);
    f[0]++;
    f[v[i]]++;
    swag.push_back(f);
    if(swag.size()==m){
      FPS g=swag.prod();
      debug(g);
      cout<<g[0]-1<<'\n';
      swag.pop_front();
    }
  }
}
yukicoder

結果

テストケース

ソースコード
