[bzoj3167][HEOI2013]SAO

题目大意

现在有N个点，两个点之间存在有向关系。无视关系的方向性后，N个点组成一颗树。现在问对该图做拓扑排序有多少种方法？N<=1000。

当作树一样考虑

我们无视方向，把它当作一颗树，随意找一个点作根然后进行处理。
假设当前做到点x，先将x所有子树都做完，再把x与子树两两合并。
于是现在摆在我们面前的问题是：如何用状态表示一个图，并能快速实现合并两个只存在一条联系的图？
我们用f[i,j]表示i点当前所在的图构成所有可能的排列里，i排在第j位的方案数。
合并两个图就很显然了，我们再增加前缀和与后缀和进行优化，便可以将合并复杂度缩小到两个图大小的乘积。理论上，此时总复杂度是N^3的。

证明复杂度

我们发现合并复杂度与图的大小有关，最坏情况是树是满二叉树时，复杂度为n^2 log n。

参考程序

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
using namespace std;
typedef long long ll;
const ll maxn=1000+10,mo=1000000007;
ll f[maxn][maxn],g[maxn],ff[maxn],gg[maxn],s[maxn],pre[maxn][maxn],suf[maxn][maxn];
ll h[maxn],go[maxn*2],next[maxn*2],fx[maxn*2];
ll i,j,k,l,t,n,m,ca,ans,tot;
char ch;
ll quicksortmi(ll x,ll y){
    if (!y) return 1;
    ll t=quicksortmi(x,y/2);
    t=t*t%mo;
    if (y%2) t=t*(x%mo)%mo;
    return t;
}
ll c(ll x,ll y){
    if (x==0) return 1;
    return ff[y]*gg[x]%mo*gg[y-x]%mo;
}
void add(ll x,ll y,ll z){
    go[++tot]=y;
    fx[tot]=z;
    next[tot]=h[x];
    h[x]=tot;
}
void dfs(ll x,ll y){
    ll i,j,k,l,t=h[x];
    s[x]=1;
    while (t){
        if (go[t]!=y){
            dfs(go[t],x);
            s[x]+=s[go[t]];
        }
        t=next[t];
    }
    fo(i,1,s[x]) g[i]=0;
    f[x][1]=1;
    j=1;
    t=h[x];
    while (t){
        if (go[t]!=y){
            if (fx[t]==1){
                fo(k,1,j)
                    fo(l,1,s[go[t]])
                        g[k+l-1]=(g[k+l-1]+c(k-1,k+l-2)*c(j-k,j+s[go[t]]-k-l+1)%mo*f[x][k]%mo*suf[go[t]][l]%mo)%mo;
            }
            else{
                fo(k,1,j)
                    fo(l,1,s[go[t]])
                        g[k+l]=(g[k+l]+c(k-1,k+l-1)*c(j-k,j+s[go[t]]-k-l)%mo*f[x][k]%mo*pre[go[t]][l]%mo)%mo;
            }
            j+=s[go[t]];
            fo(i,1,j) f[x][i]=g[i];
            fo(i,1,j) g[i]=0;
        }
        t=next[t];
    }
    pre[x][1]=f[x][1];
    fo(i,2,s[x]) pre[x][i]=(pre[x][i-1]+f[x][i])%mo;
    suf[x][s[x]]=f[x][s[x]];
    fd(i,s[x]-1,1) suf[x][i]=(suf[x][i+1]+f[x][i])%mo;
}
int main(){
    ff[0]=1;
    fo(i,1,1000) ff[i]=ff[i-1]*i%mo;
    gg[1000]=quicksortmi(ff[1000],mo-2);
    fd(i,999,0) gg[i]=gg[i+1]*(i+1)%mo;
    scanf("%lld",&ca);
    while (ca--){
        scanf("%lld",&n);
        fo(i,1,n)
            fo(j,1,n)
                f[i][j]=0;
        fo(i,1,n-1){
            scanf("%lld",&j);
            j++;
            ch=getchar();ch=getchar();
            scanf("%lld",&k);
            k++;
            if (ch=='>') swap(j,k);
            add(j,k,1);
            add(k,j,-1);
        }
        dfs(1,0);
        ans=0;
        fo(i,1,n) ans=(ans+f[1][i])%mo;
        printf("%lld\n",ans);
        fo(i,1,tot) h[i]=0;
        tot=0;
    }
}