poj 3272——Cow Traffic——树形dp

题目链接：

http://poj.org/problem?id=3272

题目大意：

给定一张有向图，以度数为0的点为起点，以n号点为终点，求经过的边中最频繁的边被经过的次数。

解题思路：

开始的时候看错了题目，以为是求起点到终点的所有的路径数目，主要是被Hint坑了。

后来看了下别人讲的题目意思，就比较容易。

我的做法如下：

定义了两个数组：

dp1[i]，表示每个点到终点路径数目的总数。

dp2[i]，表示起点到每个点路径数目的总数。

对于边（u，v），经过的次数就应该是dp2[u]*dp1[v]。

状态转移方程：

dp1[u]+=dp1[v]，v是u的孩子节点。

dp2[v]+=dp2[u]，u是v的父亲节点。

源代码：

//有向图路径的数目
#include<stdio.h>
#include<iostream>
#include<math.h>
#include<string.h>
#include<string>
#include<map>
#include<vector>
#include<set>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N=50005;          //点的个数
const int M=500005;         //边的条数
int n,m;
int to[M],next[M],first[M],edgecnt,Count[M],from[M];
vector<int> pre[N];     //记录每个点的父亲节点
int du[N];
LL dp1[N];      //从这个点出发到终点的路径数目
LL dp2[N];      //起点到该点路径数目的总和
void add(int u,int v)
{
    pre[v].push_back(u);
    from[edgecnt]=u;
    to[edgecnt]=v;
    next[edgecnt]=first[u];
    first[u]=edgecnt++;
    return;
}
LL dfs(int now)     //求每个点到终点的路径的数目
{
    int i,kid;
    LL rt;
    if(dp1[now]!=0)
        return dp1[now];
    rt=0;
    for(i=first[now];i!=-1;i=next[i])
    {
        kid=to[i];
        rt+=dfs(kid);
    }
    dp1[now]=rt;
    return rt;
}
LL dfs2(int now)   //求起点到每个点路径数目之和
{
    int i,j,len,father;
    LL rt;
    if(dp2[now])
        return dp2[now];
    len=pre[now].size();
    rt=0;
    for(i=0;i<len;i++)
    {
        father=pre[now][i];
        rt+=dfs2(father);
    }
    dp2[now]=rt;
    return rt;
}
int main()
{
	freopen("in.txt","r",stdin);
	int i,j,k,t,a,b;
	LL ans;
	while(scanf("%d%d",&n,&m)==2)
    {
        edgecnt=0;
        memset(du,0,sizeof(du));
        memset(first,-1,sizeof(first));
        memset(pre,0,sizeof(pre));
        while(m--)
        {
            scanf("%d%d",&a,&b);
            du[b]++;
            add(a,b);
        }
        memset(dp1,0,sizeof(dp1));
        memset(dp2,0,sizeof(dp2));
        dp1[n]=1;
        ans=0;
        for(i=1;i<=n;i++)
            if(du[i]==0)
            {
                dp2[i]=1;
                dfs(i);
            }

        for(i=n;i>=1;i--)
            if(dp2[i]==0)
                dfs2(i);

        LL Max=0;
        for(i=0;i<edgecnt;i++)
        {
            a=from[i];
            b=to[i];
            if(dp2[a]*dp1[b]>Max)
            {
                //printf("%d %d\n",a,b);
                Max=dp2[a]*dp1[b];
            }
        }
        printf("%lld\n",Max);
    }
	return 0;
}