[CTSC2018]青蕈领主

[CTSC2018]青蕈领主

题解

首先，连续段要知道结论：

连续段要么不交，要么包含

所以是一棵树！每个位置的father是后面第一个包含它的

树形DP！

设dp[x]，x为根的子树，（设管辖的区间长度为len，也即L[x]），用1~len的数填充，满足L的方案数

也就是，每个son内部合法，

给每个son分配标号区间，使得相邻儿子不会再接在一起

不会再接在一起？

所以可以把每个儿子看成单独一个点，就划归成了：1,1,1,1,...len的方案数！

设f[i]表示，长度为i+1的1,1,1,1....i+1的序列的合法方案数。

$dp[x]=(\Pi dp[son])\times f[L[x]]$

归纳一下，可得$ans=\Pi f[|son(x)|]$,$|son(x)|$表示x的儿子个数

求f[n]？

考虑变成排列的逆！

（也就是把映射矩阵的横纵坐标意义交换）

这样，n+1成为了天然的分割点。

f[n-1]中，填入1，

要么之前合法。

要么1分开了一些东西

|son(x)|可以直接单调栈

注意，Poly每次clear需要重新resize

#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
    char ch;x=;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/)output(x/);putchar(x%+'');}
template<class T>il void ot(T x){if(x<) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=;
int ad(int x,int y){return (x+y)>=mod?x+y-mod:x+y;}
void inc(int &x,int y){x=ad(x,y);}
int sub(int x,int y){return ad(x,mod-y);}
int mul(int x,int y){return (ll)x*y%mod;}
void inc2(int &x,int y){x=mul(x,y);}
int qm(int x,int y=mod-){int ret=;while(y){if(y&) ret=mul(x,ret);x=mul(x,x);y>>=;}return ret;}
template<class ...Args>il int ad(const int a,const int b,const Args &...args) {return ad(ad(a,b),args...);}
template<class ...Args>il int mul(const int a,const int b,const Args &...args) {return mul(mul(a,b),args...);}
}
using namespace Modulo;
namespace Miracle{
const int N=+;
const int G=;
const int GI=;
int n,T;
int L[N];
struct Poly{
    vector<int>f;
    Poly(){f.clear();}
    il int &operator[](const int &x){assert(x<f.size());return f[x];}
    il void resize(int n){f.resize(n);}
    il int size(){return f.size();}
    il void clear(){f.clear();}
    il void out(){for(reg i=;i<(int)f.size();++i) ot(f[i]);putchar('\n');}
}f;
int rev[*N];
int init(int n){
    int m=;
    for(m=;m<n;m<<=);
    for(reg i=;i<m;++i){
        rev[i]=(rev[i>>]>>)|((i&)?m>>:);
    }
    return m;
}
void NTT(Poly &f,int c){
    int n=f.size();
    for(reg i=;i<n;++i){
        if(i<rev[i]) swap(f[i],f[rev[i]]);
    }
    for(reg p=;p<=n;p<<=){
        int gen;
        if(c==) gen=qm(G,(mod-)/p);
        else gen=qm(GI,(mod-)/p);
        for(reg l=;l<n;l+=p){
            int buf=;
            for(reg i=l;i<l+p/;++i){
                int tmp=mul(f[i+p/],buf);
                f[i+p/]=ad(f[i],mod-tmp);
                f[i]=ad(f[i],tmp);
                buf=mul(buf,gen);
            }
        }
    }
    if(c==-){
        int iv=qm(n);
        for(reg i=;i<n;++i){
            f[i]=mul(f[i],iv);
        }
    }
}
il Poly operator *(Poly F,Poly G){
    int n=init(F.size()+G.size()-);
    F.resize(n);G.resize(n);
    NTT(F,);NTT(G,);
    for(reg i=;i<n;++i) F[i]=mul(F[i],G[i]);
    NTT(F,-);
    return F;
}
void divi(int l,int r){

    if(l==&&r==){
        f[]=;f[]=;return;
    }
    if(l==r){
        f[l]=ad(f[l],mod-mul(f[],f[l-],l-));
        f[l]=ad(f[l],mul(l-,f[l-]));
        return;
    }
    int mid=(l+r)>>;
    divi(l,mid);
    // cout<<" divi ---------------------------"<<l<<" "<<r<<endl;
    Poly F,G,K;
    if(l==){
        // goto s;
        // cout<<"sol1---- "<<endl;
        F.resize(mid+);
        G.resize(mid+);
        for(reg i=;i<=mid;++i){
            F[i]=f[i];
            G[i]=mul(f[i],i-);
        }
        // F.out();
        // G.out();
        // cout<<"hahahaha "<<endl;
        F=F*G;
        // F.out();

        for(reg i=mid+;i<=r;++i){
            f[i]=ad(f[i],F[i]);
        }
        // cout<<" over "<<endl;
    }else{

        // cout<<"sol2**** "<<endl;
        F.resize(mid-l+);
        G.resize(r-l+);
        for(reg i=;i<=mid-l;++i){
            F[i]=f[i+l];
        }
        for(reg i=;i<=r-l;++i){
            G[i]=mul(f[i],i-);
        }
        // F.out();
        // G.out();
        // cout<<" mul "<<endl;
        K=F*G;
        // cout<<" K "<<endl;
        // K.out();

        for(reg i=mid+;i<=r;++i){
            f[i]=ad(f[i],K[i-l]);
        }

        F.clear();G.clear();
        F.resize(mid-l+);G.resize(r-l+);

        // cout<<F.size()<<" len "<<mid-l+1<<endl;
        for(reg i=;i<=mid-l;++i){
            F[i]=mul(f[i+l],i+l-);
        }
        // cout<<" OK ? "<<endl;
        for(reg i=;i<=r-l;++i){
            G[i]=f[i];
        }

        K=F*G;
        for(reg i=mid+;i<=r;++i){
            f[i]=ad(f[i],K[i-l]);
        }
    }
    // s:;
    // cout<<" end "<<f[3]<<endl;
    divi(mid+,r);
}
int sta[N],top;
int main(){
    rd(T);rd(n);
    int m=init(n+);
    f.resize(m);

    divi(,m-);
    // f.out();

    while(T--){
        for(reg i=;i<=n;++i) rd(L[i]);
        top=;
        if(L[n]!=n) {
            puts("");continue;
        }
        int ans=;
        bool fl=true;
        for(reg i=;i<=n;++i){
            int son=;
            while(top&&sta[top]-L[sta[top]]+>=i-L[i]+) ++son,--top;
            // cout<<" ii "<<i<<" son "<<son<<endl;
            if(top){
                if(sta[top]>=i-L[i]+) fl=false;
            }
            sta[++top]=i;
            ans=mul(ans,f[son]);
        }
        if(!fl) ans=;
        printf("%d\n",ans);
    }
    return ;
}

}
signed main(){
    Miracle::main();
    return ;
}

/*
   Author: *Miracle*
*/

树形结构！

然后递归为子问题。

递归为子问题，把。。。看成。。。。

本质就是“缩点”找相似结构。或者归纳