HDU 4661 Message Passing（树形DP）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4661

题意：一个n个节点的树。每个节点上有一个人。每个人有一条信息，每个人的信息各不相同。定义一次操作为可以选择两个相邻节点，其中一个节点的人可以将其所知道的所有信息传递给另一个人。使用最少的操作次数使得每个人都知道n条信息。问题还不是这个，问题是，有多少种不同方案可以使得操作次数达到最小？

思路：使得最小操作次数的方案为先将所有信息汇集到一个人那里，然后再从那里传递给每个人。这个题解说是用数学归纳法证明，可以人肉出2、3、4个节点的观察下。那么，现在就是枚举中心节点，计算以该节点为中心节点u的拓扑排序数Xu，那么总的答案为：

下面，我们说什么是拓扑排序数？就是从根节点开始，沿着每个边依次遍历每个点的不同走法。比如对于树：n=4,边为(1,2)(1,3)(2,4)，边的编号依次为1,2,3，设根为1，那么不同的遍历方案有（这里写的是边的序号）：（1,3,2）（1,2,3）（2,1,3）三种。我们说以1为根的拓扑排序数为3。

到这里，我们说怎么求以每个节点的拓扑排序数？首先DFS一次，记录f[u],size[u]，f[u]为以u为根的子树的拓扑排序数，size[u]为以u为子树的节点个数。这里，涉及到如何合并两个子树，比如u的两个子树v1，v2，那么合并后的拓扑排序数为:

那么对于u节点的所有孩子，可以采用两两合并两个孩子为一个孩子的方法，最后得到f[u]。接着第二次DFS，得到以每个节点为根的f值。将所有的f值的平方相加即为答案。

另外，比赛的时候可能不爆栈，我开始写DFS交到hdu4661上是爆栈的。改成非递归的才能ac。。

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <map>
#include <ctype.h>
#include <time.h>
   
   
#define abs(x) ((x)>=0?(x):-(x))
#define i64 long long
#define u32 unsigned int
#define u64 unsigned long long
#define clr(x,y) memset(x,y,sizeof(x))
#define CLR(x) x.clear()
#define ph(x) push(x)
#define pb(x) push_back(x)
#define Len(x) x.length()
#define SZ(x) x.size()
#define PI acos(-1.0)
#define sqr(x) ((x)*(x))
#define MP(x,y) make_pair(x,y)
#define EPS 1e-6
   
   
#define FOR0(i,x) for(i=0;i<x;i++)
#define FOR1(i,x) for(i=1;i<=x;i++)
#define FOR(i,a,b) for(i=a;i<=b;i++)
#define FORL0(i,a) for(i=a;i>=0;i--)
#define FORL1(i,a) for(i=a;i>=1;i--)
#define FORL(i,a,b)for(i=a;i>=b;i--)
   
   
#define rush() int CC;for(scanf("%d",&CC);CC--;)
#define Rush(n)  while(scanf("%d",&n)!=-1)
using namespace std;
   
   
void RD(int &x){scanf("%d",&x);}
void RD(i64 &x){scanf("%lld",&x);}
void RD(u64 &x){scanf("%I64u",&x);}
void RD(u32 &x){scanf("%u",&x);}
void RD(double &x){scanf("%lf",&x);}
void RD(int &x,int &y){scanf("%d%d",&x,&y);}
void RD(i64 &x,i64 &y){scanf("%lld%lld",&x,&y);}
void RD(u32 &x,u32 &y){scanf("%u%u",&x,&y);}
void RD(double &x,double &y){scanf("%lf%lf",&x,&y);}
void RD(double &x,double &y,double &z){scanf("%lf%lf%lf",&x,&y,&z);}
void RD(int &x,int &y,int &z){scanf("%d%d%d",&x,&y,&z);}
void RD(i64 &x,i64 &y,i64 &z){scanf("%lld%lld%lld",&x,&y,&z);}
void RD(u32 &x,u32 &y,u32 &z){scanf("%u%u%u",&x,&y,&z);}
void RD(char &x){x=getchar();}
void RD(char *s){scanf("%s",s);}
void RD(string &s){cin>>s;}
   
   
void PR(int x) {printf("%d\n",x);}
void PR(int x,int y) {printf("%d %d\n",x,y);}
void PR(i64 x) {printf("%I64d\n",x);}
void PR(i64 x,i64 y) {printf("%lld %lld\n",x,y);}
void PR(u32 x) {printf("%u\n",x);}
void PR(u64 x) {printf("%llu\n",x);}
void PR(double x) {printf("%.0lf\n",x);}
void PR(double x,double y) {printf("%.6lf %.5lf\n",x,y);}
void PR(char x) {printf("%c\n",x);}
void PR(char *x) {printf("%s\n",x);}
void PR(string x) {cout<<x<<endl;}


void upMin(int &x,int y) {if(x>y) x=y;}
void upMin(i64 &x,i64 y) {if(x>y) x=y;}
void upMin(double &x,double y) {if(x>y) x=y;}
void upMax(int &x,int y) {if(x<y) x=y;}
void upMax(i64 &x,i64 y) {if(x<y) x=y;}
void upMax(double &x,double y) {if(x<y) x=y;}
   
const int mod=1000000007;
const i64 inf=((i64)1)<<60;
const double dinf=1000000000000000000.0;
const int INF=100000000;
const int N=1000005;


struct node
{
    int v,next;
};


node edges[N<<1];
int head[N],e;


void Add(int u,int v)
{
    edges[e].v=v;
    edges[e].next=head[u];
    head[u]=e++;
}


i64 f[N];
int n,size[N];


i64 exGcd(i64 a,i64 b,i64 &x,i64 &y)
{
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    i64 temp=exGcd(b,a%b,x,y);
    i64 t=x;
    x=y;
    y=t-a/b*y;
    return temp;
}


i64 reverse(i64 a,i64 b)
{
    i64 x,y;
    exGcd(a,b,x,y);
    x=(x%b+b)%b;
    return x;
}


i64 p[N];


void init()
{
    p[0]=1;
    int i;
    for(i=1;i<N;i++) p[i]=p[i-1]*i%mod;
}


i64 get(int n,int m)
{
    i64 ans=p[n]*reverse(p[m]*p[n-m]%mod,mod)%mod;
    return ans;
}


int fa[N],cur[N];
int St[N],top;


void DFS(int u,int pre)
{    
    clr(fa,-1);
    
    int i,v;
    
    FOR1(i,n) cur[i]=head[i];
    top=0; St[++top]=u;
    f[u]=1; size[u]=0;
    while(top)
    {
        u=St[top];


        for(i=cur[u];i!=-1;i=edges[i].next)
        {
            v=edges[i].v;
            if(v==fa[u]) continue;
            fa[v]=u; f[v]=1; size[v]=0;
            St[++top]=v;
            break;
        }
        if(i==-1)
        {
            top--; v=fa[u]; size[u]++;
            size[v]+=size[u];
            f[v]=f[v]*f[u]%mod*get(size[v],size[u])%mod;
        }
        else
        {
            cur[u]=edges[i].next;
        }
    }
}


i64 ans;


void dfs(int u,int pre)
{
    int i,v;
    
    top=0; St[++top]=u;
    
    while(top)
    {
        u=St[top--];
        ans=(ans+f[u]*f[u]%mod)%mod;
        
        for(i=head[u];i!=-1;i=edges[i].next)
        {
            v=edges[i].v;
            if(v==fa[u]) continue;
            i64 x=f[u]*reverse(f[v]*get(n-1,size[v])%mod,mod)%mod;
            f[v]=f[v]*x%mod*get(n-1,n-size[v])%mod;
            St[++top]=v;
        }
        
    }
}


int main()
{
    init();
    rush()
    {
        RD(n);
        int i;
        int x,y;
        FOR1(i,n) head[i]=-1; e=0;
        FOR1(i,n-1)
        {
            RD(x,y); Add(x,y); Add(y,x);
        }
        DFS(1,-1); ans=0; dfs(1,-1);
        PR(ans);
    }
}