ACM之路（13）—— 树型dp

　　最近刷了一套（5题）的树型dp题目：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=116767#overview，算是入了个门，做下总结。

　　A题是真正的入门题，只要找出所有的入度为0的点（即每棵树上最高的领导）进行树型dp即可，具体方法同B题，等到了B题再具体讲。

　　C题是给出一棵树，升序输出这棵树上所有满足条件的点，该条件是，去掉该节点以后剩下的所有子树的size不超过原数size的一半。方法是以节点1为头，预处理出所有节点的size，然后用dfs遍历所有的点，找出符合条件的点即可。

　　D题是，给出一个树（树上每个节点都有一个权值）和一个指定的size，找出满足这个size的所有子树中权值最大的一颗子树的权值。因为节点数最大为100，所以只要暴力dp即可。

　　虽然CD两题都不是很难，但还是需要注意一下写法的。

　　重点讲下B和E两题。题意都差不多，给出一棵树，B题是每个点都可以覆盖其相邻的一条边，求覆盖所有边所需最少的点的个数。而E题是，每个点都可以覆盖自己和相邻的节点，求覆盖所有点所需的最少的点的个数。

　　一开始并没有觉得有什么区别，因为都是无环的树，应该B题的方法适用于E，不过最后还是找出了反例。

　　如上图，如果是覆盖所有点，那么只要2，5两个点即可，如果是覆盖边，那么3，4之间的边仍未覆盖，所以有不同，需要采取新的dp方法。

　　对于B题，考虑如果u点不设置点，那么即dp[u][0]=dp[v][1]，即其子节点一定要放一个点（1表示放，0表示不放）；否则，如果u点放置，则dp[u][1]=min(dp[v][0],dp[v][1])。然后用dfs遍历即可。代码如下：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;
const int N = 1500;
int dp[N+5][2];
vector<int> vec[N+5];
void dfs(int u,int f)
{
    dp[u][0]=0;
    dp[u][1]=1;
    for(int i=0;i<vec[u].size();i++)
    {
        int v=vec[u][i];
        if(f==v) continue;
        dfs(v,u);
        dp[u][0]+=dp[v][1];
        dp[u][1]+=min(dp[v][1],dp[v][0]);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=N;i++) vec[i].clear();
        for(int i=1;i<=n;i++)
        {
            int u,T;
            scanf("%d:(%d)",&u,&T);
            while(T--)
            {
                int v;
                scanf("%d",&v);
                vec[u].push_back(v);
                vec[v].push_back(u);
            }
        }
        dfs(0,-1);
        int ans = min(dp[0][0],dp[0][1]);
        printf("%d
",ans);
    }
    return 0;
}

　　

　　对于D题，贪心策略是如果子节点建了，父节点不建；父节点建了，子节点不建。具体的还是见代码理解一下吧：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;

vector<int> G[10000+5];
int build[100000+5];
int ans = 0;
void dfs(int u,int from)
{
    int f = 0; //f=1表示所有子代中具有一个已经放置了点
    for(int i=0;i<G[u].size();i++)
    {
        int &v = G[u][i];
        if(v == from) continue;
        dfs(v,u);
        f = f||build[v];
    }
    if(from == -1) ans += (f==0&&build[u]==0);
    else if(build[from] == 0 && build[u] == 0 && f == 0)
    {
        ans++;
        build[from] = 1; //这是贪心策略的体现，可以手动画图模拟一下
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        for(int i=1;i<=n;i++) G[i].clear();
        memset(build,0,sizeof(build));
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        ans = 0;
        dfs(1,-1);
        printf("%d
",ans);
    }
}

 模拟过程大致如下：

 

由于贪心策略，最后三个节点不涂，倒数第二个涂色，那么3自然不用涂，回溯到2节点的时候，由于1，2，3都没涂，而3是有三个儿子节点可以覆盖它的，故不用管，所以涂1即可，这就是代码中，连续3个没涂的情况下涂最前面那个（也就是from）的缘故。同时这也是和B题不同的一个反例。因为2，3之间的边没被覆盖。