HDU 2196 树形DP

题目链接

题意：

给定一颗树，求树上各点的最大可到距离。

思路：

定义dp数组和son数组：

dp[u][0]：表示从u向下可以到达的最大距离

dp[u][1]：表示从u向下可以到达的次大距离

dp[u][2]：表示从u向上先到父结点后再可以到达的最大距离

son[u]：表示从u向下可以到达的最大距离经过的子结点

dp[u][0]和dp[u][1]进行一遍dfs1即可求得

dp[u][2]：需要分两种情况：

情况1：v是son[u]，那么dp[v][2] = max ( dp[u][1] , dp[u][2] )

情况2：v不是son[u]，那么dp[v][2] = max ( dp[u][0] , dp[u][2] )

C++代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 10010;

int n,tol,head[maxn];
struct edge
{
    int to,next,cost;
}es[maxn];

void addedge( int u , int v , int w )
{
    es[tol].to = v;
    es[tol].cost = w;
    es[tol].next = head[u];
    head[u] =  tol++;
}

int dp[maxn][5];
int son[maxn];

void dfs1( int u , int f )
{
    dp[u][0] = 0;
    dp[u][1] = 0;
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to;
        int w = es[i].cost;
        dfs1( v , u );
        int t = dp[v][0]+w;
        if ( son[u]==-1||t>dp[u][0] )
        {
            dp[u][1] = dp[u][0];
            dp[u][0] = t;
            son[u] = v;
        }
        else if ( t<=dp[u][0]&&t>dp[u][1] )
        {
            dp[u][1] = t;
        }
    }
}

void dfs2( int u , int f )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to,w = es[i].cost;
        if ( v!=son[u] )
            dp[v][2] = w+max( dp[u][0] , dp[u][2] );
        else
            dp[v][2] = w+max( dp[u][1] , dp[u][2] );
        dfs2( v , u );
    }
}

int main()
{
    while( scanf( "%d" , &n )==1 )
    {
        tol = 0; memset ( head , -1 , sizeof(head) );
        for ( int i=2 ; i<=n ; i++ )
        {
            int f,w; scanf ( "%d%d" , &f , &w );
            addedge( f , i , w );
        }
        memset ( son , -1 , sizeof(son) );
        dfs1( 1 , 0 );
        dfs2( 1 , 0 );
        for ( int i=1 ; i<=n ; i++ )
            printf ( "%d\n" , max( dp[i][0] , dp[i][2] ) );
    }
    return 0;
}