hdu2196 树形dp

题意：
给出一颗带权树，求以树上每个点为起点可以到达的最大边权和。
思路：
树形dp的思想，将无根树转化为有根树，对于每个点来说，最长的一条路可能有两种情况，一是向下走，经过其某个子树。另一种情况是向上走，由其父亲延伸而来。
以dp[i][0]表示由i节点向下可以得到的最长边权和，dp[i][0] = max(dp[k][0] + value[k])，k为i的子节点。
一次dfs可以得到所有的dp[i][0]
以dp[i][1]表示由i节点向上可以得到的最长边权和，这里有两种情况，如果dp[p[i]][0]所代表的最长路径没有经过i点，那么dp[i][1] = value[i] + max(dp[p[i]][0],dp[p[i]][1])。
如果dp[p[i]][0]所代表的最长路径经过了i点，那么dp[i][1] =value[i] + max(p[i]节点的次大向下边权路径和 + dp[p[i]][1])。也就是说我们需要在用dfs求dp[i][0]的时候记录下其次大值以及最大值经过的子节点编号。
根据转移方程可知，应该从根节点开始递推，这里采用dfs,bfs均可。最后取出每个节点向上和向下的最大值即可。

#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;
const int size = 10005;
int p[size];
int value[size];
int dp[size][2];
int semx[size];
int mnode[size];
int n;
bool visit[size];
vector<int> v[size];
void initial()
{
    for(int i = 0; i <= n;i++)
        v[i].clear();
    memset(p, 0, sizeof(p));
    memset(semx, 0, sizeof(semx));
    memset(dp, 0, sizeof(dp));
    memset(value, 0, sizeof(value));
    memset(visit, false, sizeof(visit));
    memset(mnode,0, sizeof(mnode));
}
int dfs(int a)
{
    for(int i = 0; i < v[a].size(); i++)
    {
        int per = dfs(v[a][i]);
        per += value[v[a][i]];
        if(per > dp[a][0])
        {
            semx[a] = dp[a][0];
            dp[a][0] = per;
            mnode[a] = v[a][i];
        }
        else
            semx[a] = max(semx[a], per);
    }
    return dp[a][0];
}
void bfs()
{
    queue<int> q;
    q.push(1);
    visit[1] = true;
    while(!q.empty())
    {
        int par = q.front();
        q.pop();
        for(int i = 0; i < v[par].size(); i++)
        {
            int maxs = (mnode[par] == v[par][i]) ? semx[par] : dp[par][0];
            if(p[par])
                maxs = max(maxs,dp[par][1]);
            dp[v[par][i]][1] = maxs + value[v[par][i]];
            q.push(v[par][i]);
            visit[v[par][i]] = true;
        }
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        initial();
        for(int i = 2; i <= n ;i++)
        {
            int m,k;
            scanf("%d%d",&m,&k);
            v[m].push_back(i);
            value[i] = k;
            p[i] = m;
        }   
        dfs(1);
        bfs();
        for(int i = 1; i <= n; i++)
            printf("%d\n",max(dp[i][0],dp[i][1]));
    }
    return 0;
}