简单树形DP

    树形DP，即是在一颗树上进行DP，一般是有叶子节点状态推出根节点状态。结合几个简单例子分析。

例1. POJ2342/POJ3342

【题意】

公司有n个人，每个人有价值vi，有一天举办年会，每个人都可以参加，但有严格的等级制度，参加活动时，不能同时出现a和a的上司，问如何才能使总和最大。

【分析】

每个人只有去和不去两种状态，设DP[i][0]和DP[i][1]分别表示第i个人不参加和参加年会，获得的总的最大价值。

则状态转移方程为：

DP[i][1] += DP[j][0],

DP[i][0] += max{DP[j][0],DP[j][1]};其中j为i的孩子节点。

这样，从根节点r进行dfs，最后结果为max{DP[r][0],DP[r][1]}。

POJ3342与上面类似，多了一个问题问最后最大的结果是不是唯一的，判断唯一性：当某个节点i取不取一样，并且它的某个孩子节点取不取一样，那么结果才不唯一。

例2. HDU2196

【题意】

一棵树，询问一颗树上每个点离它最远的点是哪个？

【分析】

一棵树上离它最远的点必定在树的直径上（否则可以找到离它更远的点），到底是两端点的哪个点呢？

求树的直径：从任意一点BFS，得到最远点k，则k点必定是树的直径其中一端点，再从k点BFS，得到另一端点j，在求解过程中用两个数组记录其它点到这两点的距离，最后比较较大者为答案。

例3. POJ1463

【题意】

一颗树，n个节点，现在要在节点处设置尽量少的哨兵，使得每条边都被观察到。

【分析】

一个节点要么设立哨兵，要么不设立，若节点i不设立哨兵，则节点i的所有的孩子节点必须设立哨兵；否则，看若节点i的孩子设立哨兵的值是否

小于不设哨兵的值，取二者中的较小者。

DP[i][0] = sum{DP[j][1]},

DP[i][1] = sum{min(DP[j][1],DP[j][0])} + 1, j是i的孩子节点。

例4. POJ4045

【题意】

n个城市节点构成的一棵树，节点i和节点j的电量损耗为I*I*R*i到j的路径所含边数，现在要修建一个供电站，使得总的损耗量最小。求最小

损耗和可以修建供电站的节点。

【分析】

一种简单的想法就是枚举所有节点，然后bfs求和，复杂度为O(n^2)。

首先，选定任意一点作为根节点dfs，设两个数组num[i]和dp[i]，分别表示以节点i为根的子树的节点个数 和 根到其子节点的距离(边数)之和。

num[i] = sum{num[j]}+1，dp[i] = sum{num[j]+dp[j]}.

从root开始第二次dfs，依次考虑每个点作为根节点，考虑将x(当前根节点)的孩子y作为根节点：

dp[y] = dp[y] + (dp[x]-dp[y]-num[y])+(num[x]-num[y]) = dp[x]-2*num[y] + num[x]，记录最小值即可。

附POJ2342和POJ4045代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int Max = 6005;

struct Node
{
    int fa;
    int value;
    vector<int> child;
}node[Max];
int dp[Max][2];
bool vis[Max];

int max(int a, int b)
{
    return a>b?a:b;
}

void dfs(int now)
{
    vis[now] = true;
    int s = node[now].child.size();
    for(int i = 0; i < s; i++)
    {
        int child = node[now].child[i];
        if(!vis[child])
        {
            dfs(child);
            dp[now][1] += dp[child][0];
            dp[now][0] += max(dp[child][0],dp[child][1]);
        }
    }
}

int main()
{
    int i;
    int a,b;
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        memset(node,0,sizeof(Node));
        memset(vis,0,sizeof(vis));
        for(i = 1; i <= n; i++)
        {
            scanf("%d",&dp[i][1]);
            dp[i][0] = 0;
        }
        while(scanf("%d %d",&a,&b)!=EOF)
        {
            if(a==0&&b==0)
                break;
            node[a].fa = b;
            node[b].child.push_back(a);
        }
        int root = 1;
        for(i = 1; i <= n; i++)
        {
            if(!node[i].fa)
            {
                root = i;
                break;
            }
        }
        dfs(root);
        printf("%d\n",max(dp[root][0],dp[root][1]));
    }
    return 0;
}

 #include <iostream>

#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int Max = 51000;
typedef __int64 int64;
int n;
int I,R;

struct Edge
{
    int to;
    int next;
}e[Max*2];
int head[Max],numm;
bool vis[Max];
int64 dp[Max],num[Max];

void addEdge(int from, int to)
{
    e[numm].to = to;
    e[numm].next = head[from];
    head[from] = numm++;
}

void dfs1(int now)
{
    dp[now] = 0;
    num[now] = 1;
    vis[now] = true;
    for(int i = head[now]; i != -1; i = e[i].next)
    {
        int next = e[i].to;
        if(!vis[next])
        {
            dfs1(next);
            num[now] += num[next];
            dp[now] += dp[next]+num[next];
        }
    }
}

void dfs2(int now)
{
    vis[now] = true;
    for(int i = head[now]; i != -1; i = e[i].next)
    {
        int next = e[i].to;
        if(!vis[next])
        {
            dp[next] = dp[now] - 2*num[next] + n;
            dfs2(next);
        }
    }
}

int main()
{
    int i,j;
    int t;
    int x,y;
    scanf("%d",&t);
    while(t--)
    {
        numm = 0;
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        scanf("%d %d %d",&n,&I,&R);
        for(i = 1; i < n; i++)
        {
            scanf("%d %d",&x,&y);
            addEdge(x,y);
            addEdge(y,x);
        }
        dfs1(1);
        memset(vis,0,sizeof(vis));
        dfs2(1);
        int64 result = ((int64)1)<<61;
        vector<int> ans;
        ans.clear();
        for(i = 1; i <= n; i++)
        {
            if(dp[i]<result)
            {
                ans.clear();
                ans.push_back(i);
                result = dp[i];
            }
            else if(dp[i]==result)
                ans.push_back(i);
        }
        printf("%I64d\n",result*I*I*R);
        int r = ans.size();
        for(i = 0; i < r; i++)
        {
            printf("%d",ans[i]);
            printf("%c",i==r-1?'\n':' ');
        }
        printf("\n");
    }
    return 0;
}