简单树形DP
树形DP，即是在一颗树上进行DP，一般是有叶子节点状态推出根节点状态。结合几个简单例子分析。
【题意】
公司有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;
}