[GCJ2017R3]Cooclement

题目大意：
　　一种数列按照如下方式变化：
　　新数列第i位等于原数中数字i的出现次数。
　　变化过程中数列长度不变。
　　例如数列12的变化过程为12-11-20-01-10。
　　现在告诉你一个数列x，请求出x可能是有几种数列变化而来的。

思路：
　　将整个变化过程倒过来，除去自环就是一棵树。
　　题目就变成了求子树的大小。
　　显然枚举一个状态所有的前驱（即树上的子结点）会超时，只有25分。
　　然而如果只是求出一个状态对应的后继（父结点）会很简单。
　　我们可以枚举出所有的状态，然后求出其后继，最后拓扑排序时DP求出子树大小即可。
　　对于一些不存在的状态（各位数之和大于长度），我们则没必要遍历，可以特判判掉。
　　如果一个状态的所有前驱都是不存在的，我们可以直接用组合算出它前驱的数量。

 #include<queue>
 #include<cstdio>
 #include<cctype>
 #include<ext/hash_map>
 int n;
 inline int getint() {
     register char ch;
     n=;
     while(!isdigit(ch=getchar()));
     register int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^''),n++;
     return x;
 }
 const int N=;
 const int pow[]={,,,,,,,,};
 __gnu_cxx::hash_map<int,int> size[N];
 inline int fact(const int &n) {
     int ret=;
     for(register int i=;i<=n;i++) {
         ret*=i;
     }
     return ret;
 }
 inline int comb(const int &n,const int &m) {
     return fact(n-m);
 }
 __gnu_cxx::hash_map<int,int> deg[N];
 __gnu_cxx::hash_map<int,int> hash_table[N];
 int cnt[N];
 int hash(const int &n,const int &x) {
     if(hash_table[n].count(x)) return hash_table[n][x];
     return hash_table[n][x]=++cnt[n];
 }
 int nxt[N][];
 inline void add_edge(const int &n,const int &u,const int &v) {
     nxt[n][hash(n,u)]=hash(n,v);
     deg[n][hash(n,v)]++;
 }
 void dfs2(const int now,const int &n) {
     int next=,tmp=now;
     while(tmp) {
         next+=tmp%?pow[n-tmp%]:;
         tmp/=;
     }
     if(next==now) {
         size[n][now]--;
         return;
     }
     add_edge(n,now,next);
 }
 void dfs(const int cur,const int &n,const int now,const int sum) {
     if(sum>n) return;
     if(cur==n) {
         if(!sum||size[n].count(hash(n,now))) return;
         int &ans=size[n][hash(n,now)];
         int nn=n,num=now;
         ans=fact(nn);
         while(num) {
             ans/=fact(num%);
             nn-=num%;
             num/=;
         }
         ans/=fact(nn);
         ans++;
         dfs2(now,n);
         return;
     }
     for(int i=;i<=n;i++) {
         dfs(cur+,n,(((now<<)+now)<<)+i,sum+i);
     }
 }
 int main() {
     int T=getint();
     for(register int i=;i<=T;i++) {
         const int x=getint();
         int tmp=x,sum=;
         while(tmp) {
             sum+=tmp%;
             tmp/=;
         }
         if(sum>n) {
             printf("Case #%d: %d\n",i,);
             continue;
         }
         if(size[n].empty()) {
             dfs(,n,,);
             std::queue<int> q;
             for(register int j=;j<=cnt[n];j++) {
                 if(!deg[n][j]) {
                     q.push(j);
                 } else {
                     size[n][j]=;
                 }
             }
             while(!q.empty()) {
                 const int x=q.front();
                 q.pop();
                 size[n][nxt[n][x]]+=size[n][x];
                 if(!--deg[n][nxt[n][x]]) q.push(nxt[n][x]);
             }
         }
         printf("Case #%d: %d\n",i,size[n][hash(n,x)]);
     }
     return ;
 }