ZOJ3874 Permutation Graph

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

Edward has a permutation {a₁, a₂, … a_n}. He finds that if he connects each pair (a_i, a_j) such that i < j and a_i > a_j, he will get a graph.

For example, if the permutation is {2, 3, 1, 4}, then 1 and 2 are connected and 1 and 3 are connected.

Edward lost his permutation, but he does know the connected components of the corresponding graph. He wants to know how many permutations will result in the same connected components.

Note that two vertices u, v belong to the same connected component if there exists a sequence of vertices starting with u and ending with v such that every two subsequent vertices in the sequence are connected by an edge.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains two integers n, m (1 ≤ m ≤ n ≤ 100000), indicating the length of the permutation and the number of connected components in the graph.

Each of the following m lines contains an integer c_i which denotes the size of i-th connected component, followed by c_i distinct integers v_i,1, v_i,2, … v_i,ci which denotes the connected component (1 ≤ c_i, v_i,1, v_i,2, … v_i,ci ≤ n).

It is guaranteed that every number will appear in exact one connected component and c₁ + c₂ + … + c_m = n.

Output

For each case, output the answer modulo 786433.

Sample Input

2
4 4
1 1
1 2
1 3
1 4
4 2
3 1 2 3
1 4

Sample Output

1
3

Hint

For the second case, the three permutations is: {2, 3, 1, 4}, {3, 2, 1, 4}, {3, 1, 2, 4}.

---

Author: LIN, Xi
Source: The 12th Zhejiang Provincial Collegiate Programming Contest

 

 

动态规划 分治NTT优化

随意脑补一下可以发现构成连通块的数排序后一定是连续+1递增的一串，不然它们中肯定有数连到别的地方去。

设f[i]表示大小恰好为i的连通块的方案数首先列出一个简单粗暴的方程：

　$ f[i]=\sum_{j=1}^{i} A_{j}^{j} * f[i-j] $

　$ A_{j}^{j}=j!$

复杂度$O(n^2)$

注意到右边构成了一个卷积的形式，且每个f都只由比它小的f计算得到。

于是可以愉快地用分治NTT优化DP

（前置技能：CDQ分治）

分治NTT理解了以后其实挺简单的，利用CDQ分治计算整个序列，当处理一个区间时，该区间的前一半已经被算完了，只需要把前一半的项卷积一下，答案累加到下标对应的后一半位置去，如此递归分治即可。

 

注意NTT的数组空间要开到(mid-l+1)的两倍。刚开始想当然觉得for(N=1,len=0;N<=m;N<<=1)等价，实际上这样做的话N会停在某个比size大，比2*size小的2的幂上

786433的原根是10  ←不知为什么记成11，调了半天

/*by SilverN*/
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#define LL long long
using namespace std;
const int mod=786433;
const int G=10;
const int mxn=100010;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
LL fac[mxn];
void init(){
    fac[0]=1;
    for(int i=1;i<mxn;i++)fac[i]=(LL)fac[i-1]*i%mod;
    return;
}
LL ksm(LL a,LL k){
    int res=1;
    while(k){
        if(k&1)res=(LL)res*a%mod;
        a=(LL)a*a%mod;
        k>>=1;
    }
    return res;
}
LL a[mxn<<1],b[mxn<<1];
int N,len,rev[mxn<<1];
void NTT(LL *a,int flag){
    for(int i=0;i<N;i++)if(i<rev[i])swap(a[i],a[rev[i]]);
    for(int i=1;i<N;i<<=1){
        int p=i<<1;
        LL gn=ksm(G,(flag==1)?(mod-1)/p:(mod-1)-(mod-1)/p);
        for(int j=0;j<N;j+=p){
            LL g=1;
            for(int k=0;k<i;k++,g=(LL)g*gn%mod){
                LL x=a[j+k],y=g*a[j+k+i]%mod;
                a[j+k]=(x+y)%mod;
                a[j+k+i]=(x-y+mod)%mod;
            }
        }
    }
    if(flag==-1){
        LL INV=ksm(N,mod-2);
        for(int i=0;i<N;i++)a[i]=(LL)a[i]*INV%mod;
    }
    return;
}
LL f[mxn];
void solve(int l,int r){
    if(l==r){
        f[l]=((fac[l]-f[l])%mod+mod)%mod;
        //当l==r时，比l小的f全都算完了，可以得出f[l]=fac[l]-f[l] 
        return;
    }
    int i,j,mid=(l+r)>>1;
    solve(l,mid);//先算前一半 
    int m=(mid-l+1)<<1;//空间开两倍 
    for(N=1,len=0;N<=m;N<<=1)len++;
    for(i=0;i<N;i++)rev[i]=(rev[i>>1]>>1)|((i&1)<<(len-1));
    for(i=0;i<N;i++)a[i]=b[i]=0;
    for(i=l;i<=mid;i++)//为了节省空间，将每一项左移l位计算
        a[i-l]=f[i];
    for(i=l;i<=r;i++)b[i-l]=fac[i-l];
    //
    NTT(a,1);NTT(b,1);
    for(i=0;i<N;i++)a[i]=(LL)a[i]*b[i]%mod;
    NTT(a,-1);
    for(i=mid+1;i<=r;i++){//将贡献累加到右半边 
        (f[i]+=a[i-l])%=mod;
    }
    solve(mid+1,r);
    return;
}
int n;
int num[mxn];
bool check(int x){
    sort(num+1,num+x+1);
    for(int i=2;i<=x;i++){
        if(num[i]!=num[i-1]+1)return 0;
    }
    return 1;
}
int main(){
    int i,j;
    init();
    f[0]=1;
    solve(1,100000);
    int T=read(),m;
    while(T--){
        n=read();m=read();
        bool flag=1;
        LL ans=1;
        for(i=1;i<=m;i++){
            int sz=read();
            for(j=1;j<=sz;j++)num[j]=read();
            if(!check(sz))flag=0;
            ans=(ans*f[sz])%mod;
        }
        if(!flag)puts("0");
        else printf("%lld\n",ans);
    }
    return 0;
}