hdu3534，个人认为很经典的树形dp

题目大意为，求一个树的直径（最长路），以及直径的数量

朴素的dp只能找出某点开始的最长路径，但这个最长路径却不一定是树的直径，本弱先开始就想简单了，一直wa

直到我看了某位大牛的题解。。。

按照那位大牛的思路，我们来考虑直径的构成：

情况1：由某叶子节点出发产生的最长路径直接构成

情况2：由某有多个儿子的节点出发产生的两条长路径组成，这其中，又可以分为两条长路径长度相等与否两种情况

所以 在dp的时候，我们需要记录每个节点出发产生的最长路径和次长路径，以及他们的数量，数量的统计也是非常麻烦

详细请见代码：

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<ctype.h>
#include<algorithm>
#include<string>
#include<string.h>
#include<queue>
#define mod 998244353
#define MAX 100000000
using namespace std;
int t,n,m,p,k,tt,f;
int x;

int head[10010];
typedef struct Node
{
    int en;
    int value;
    int next;
}node;
node edge[20010];
typedef struct DPnode
{
    int dp1,dp2,len,nn;
    int n1,n2;
}DP;
DP dp[10010];
void ini()
{
    int x,y,z;
    for(int i=1;i<=n-1;i++)
    {
        scanf("%d%d%d",&x,&y,&k);
        edge[2*i-1].en=y;
        edge[2*i-1].next=head[x];
        edge[2*i-1].value=k;
        head[x]=2*i-1;
        edge[2*i].en=x;
        edge[2*i].next=head[y];
        edge[2*i].value=k;
        head[y]=2*i;
    }
}
void dfs(int s,int p)
{
    dp[s].dp1=dp[s].dp2=dp[s].len=dp[s].n1=dp[s].n2=dp[s].nn=0;
    int leaf=1;
    for(int i=head[s];i;i=edge[i].next)
    {
        int q=edge[i].en;
        if(q==p)
            continue;
        leaf=0;
        dfs(q,s);
        int tmp=dp[q].dp1+edge[i].value;
        if(tmp>dp[s].dp1)
        {
            dp[s].dp2=dp[s].dp1;
            dp[s].n2=dp[s].n1;
            dp[s].dp1=tmp;
            dp[s].n1=dp[q].n1;
        }
        else if(tmp==dp[s].dp1)
        {
            dp[s].n1+=dp[q].n1;
        }
        else if(tmp>dp[s].dp2)
        {
            dp[s].dp2=tmp;
            dp[s].n2=dp[q].n1;
        }
        else if(tmp==dp[s].dp2)
        {
            dp[s].n2+=dp[q].n1;
        }
    }
    if(leaf)
    {
        dp[s].n1=1;dp[s].nn=1;
        dp[s].len=0;
        dp[s].dp1=0;
        return;
    }
    int c1=0,c2=0;
    for(int i=head[s];i;i=edge[i].next)
    {
        int q=edge[i].en;
        if(q==p)
            continue;
        int tmp=dp[q].dp1+edge[i].value;
        if(tmp==dp[s].dp1)
            c1++;
        else if(tmp==dp[s].dp2&&dp[s].dp2)
            c2++;
    }
    if(c1>1)
    {
        dp[s].len=dp[s].dp1*2;
        int sum=0;
        for(int i=head[s];i;i=edge[i].next)
        {
            int q=edge[i].en;
            if(q==p)
                continue;
            if(dp[q].dp1+edge[i].value==dp[s].dp1)
            {
                dp[s].nn+=sum*dp[q].n1;
                sum+=dp[q].n1;
            }
        }
    }
    else if(c2>0)
    {
        dp[s].len=dp[s].dp1+dp[s].dp2;
        for(int i=head[s];i;i=edge[i].next)
        {
            int q=edge[i].en;
            if(q==p)
                continue;
            if(dp[q].dp1+edge[i].value==dp[s].dp2)
            {
                dp[s].nn+=dp[s].n1*dp[q].n1;
            }
        }
    }
    else
    {
        dp[s].len=dp[s].dp1;
        dp[s].nn=dp[s].n1;
    }
    return ;
}
void solve()
{
    int ans=0;
    int num=0;
    for(int i=1;i<=n;i++)
    {
        if(dp[i].len>ans)
        {
            ans=dp[i].len;
            num=dp[i].nn;
        }
        else if(dp[i].len==ans)
        {
            num+=dp[i].nn;
        }
    }
    printf("%d %d\n",ans,num);
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(head,0,sizeof(head));
        ini();
        dfs(1,0);
        solve();
    }
    return 0;
}