三道简单树型dp+01背包～～hdu1561，poj1947，zoj3626

以前学树型dp就是随便的看了几道题，没有特别注意树型dp中的小分类的总结，直到上次浙大月赛一道很简单的树型dp都不会，才意识到自己太水了～～come on！

hdu1561：题目给出了很多棵有根树，如果把每棵树的根节点都与0相连，则就是一棵完整的有根树了（N<=200），ACboy从根节点出发，他最多可以攻占m个城市，而每个城市的财富值不一定相同，问ACboy最多可以获得多少财富。就是以每个跟节点做01背包就可以了，dp[i][j]表示以i为根节点已经攻占了j个城市获得的最大财富。不过要注意一下最后要加上根节点的值，因为要求攻占了根节点才能往下攻占，当然节点0除外，具体见代码和注释：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#define see(x) cout<<#x<<":"<<x<<endl;
using namespace std;
const int maxn = 205;
int w[maxn], dp[maxn][maxn];
vector<int> son[maxn];
int n, m;
void dfs(int x){
    int i, j, k;
    if(son[x].size()==0){
        dp[x][1] = w[x];
        return;
    }
    for(i=0;i<son[x].size();i++){
        dfs(son[x][i]);
    }
    for(i=0;i<son[x].size();i++){
        for(j=m;j>=0;j--){
            for(k=0;k<=j;k++){
                if(dp[son[x][i]][k]!=-1&&dp[x][j-k]!=-1){
                    dp[x][j] = max(dp[x][j],dp[son[x][i]][k]+dp[x][j-k]);
                }
            }
        }
    }
/*上面就是基本树型DP加背包的基本解法了*/
    if(x!=0){  //x为0节点时，不需要这种要求
        for(j=m;j>=0;j--){//处理一下必须攻占根节点才能攻占剩下的子节点的条件，逆序正好可以处理完
            if(dp[x][j-1]!=-1){
                dp[x][j] = dp[x][j-1]+w[x];
            }
        }
    }
}
void Init(int n){
    memset(dp,-1,sizeof(dp));
    for(int i=0;i<=n;i++){
        dp[i][0] = 0;
    }
    for(int i=0;i<=n;i++){
        son[i].clear();
    }
}
int main(){
    int i, j, k, l;
    while(~scanf("%d%d",&n,&m)&&(n||m)){
        Init(n);
        for(i=1;i<=n;i++){
            scanf("%d%d",&k,&w[i]);
            son[k].push_back(i);
        }
        w[0] = 0; dfs(0);
        printf("%d\n",dp[0][m]);
    }
}

poj1947：给出一棵有根树，问孤立出大小为P的子树要断开多少边。就是一个容量为p的背包，树型dp。dp[i][j]表示以i为根孤立出j个节点的树至少需要断开多少条边，于是dp[x][j] = min{dp[x1][j1]+dp[x2][j2]+dp[x3][j3]+……+dp[xn][jn]}，j1+j2+j3+……+jn = j，但是也不是完全这样了，其实在对每个背包进行更新时，应该是dp[x][j] = min{dp[x][j],dp[son[x][i]][k]+dp[x][j-k]-2}，减2是因为要减去算了两次的x到son[x][i]的那条边，具体见代码，写的挺纠结的。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 155;
vector<int> son[maxn];
bool vis[maxn];
int dp[maxn][maxn];
int n, p;
void dfs(int root, int x){
    int i, j, k;
    if(x==root) dp[x][1] = son[x].size();
    else dp[x][1] = son[x].size()+1;

    for(i=0;i<son[x].size();i++){
        dfs(root,son[x][i]);
    }
    for(i=0;i<son[x].size();i++){
        for(j=p;j>=0;j--){
            for(k=0;k<=j;k++){
                if(dp[x][k]<maxn&&dp[son[x][i]][j-k]<maxn){
                    dp[x][j] = min(dp[x][j],dp[x][k]+dp[son[x][i]][j-k]-2);
                }
            }
        }
    }
}
void Init(int n){
    int i, j;
    for(i=0;i<=n;i++){
        for(j=0;j<=n;j++){
            dp[i][j] = maxn;
        }
        son[i].clear();
        vis[i] = 0;
    }
}
int main(){
    int i, j, k, x1, x2, ans;
    while(~scanf("%d%d",&n,&p)){
        Init(n);
        for(i=0;i<n-1;i++){
            scanf("%d%d",&x1,&x2);
            son[x1].push_back(x2);
            vis[x2] = 1;
        }
        for(i=1;i<=n;i++){
            if(!vis[i]){
                dfs(i,i);break;
            }
        }
        ans = maxn;
        for(i=1;i<=n;i++){
            ans = min(ans,dp[i][p]);
        }
        printf("%d\n",ans);
    }
}

zoj3626：这个就是上次浙大月赛的题了，题意跟hdu1561类似，给出一棵树，n-1条边有不同的边全，n个城市有不同的财富，一个人最多只可以走m/2长度，为最多可以占领多少财富。dp[i][j]表示以i为根继续走了j个长度可以获得的最大财富，自己就是在刷完hdu1561之后简单的改改顺利的a了，两道题可能可以改成一样的写法，不过想到怎么写，就怎么写了

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#define see(x) cout<<#x<<":"<<x<<endl;
using namespace std;
const int maxn = 110;
vector<int> son[maxn], w[maxn];
int val[maxn];
int dp[maxn][205];
int n, m;
void dfs(int x, int pre){
    int i, j, k;
    if(son[x].size()==1&&pre==son[x][0]){
        return;
    }
    for(i=0;i<son[x].size();i++){
        if(pre!=son[x][i]){
            dfs(son[x][i],x);
        }
    }
    for(i=0;i<son[x].size();i++){
        if(pre!=son[x][i]){
            for(j=m-w[x][i];j>=0;j--){
                for(k=0;k<=j;k++){
                    if(dp[son[x][i]][k]!=-1&&dp[x][j-k]!=-1){
                        dp[x][j+w[x][i]] = max(dp[x][j+w[x][i]],dp[son[x][i]][k]+dp[x][j-k]);
                    }
                }
            }
        }
    }
}
void Init(int n){
    memset(dp,-1,sizeof(dp));
    for(int i=0;i<=n;i++){
        son[i].clear();
        w[i].clear();
    }
}
int main(){
    int i, j, k, x1, x2, l, ans;
    while(~scanf("%d",&n)){
        Init(n);
        for(i=1;i<=n;i++){
            scanf("%d",&val[i]);
            dp[i][0] = val[i];
        }
        for(i=0;i<n-1;i++){
            scanf("%d%d%d",&x1,&x2,&l);
            son[x1].push_back(x2);w[x1].push_back(l);
            son[x2].push_back(x1);w[x2].push_back(l);
        }
        scanf("%d%d",&k,&m);
        m/=2;dfs(k,-1);
        ans = val[k];
        for(i=0;i<=m;i++){
            ans = max(ans,dp[k][i]);
        }
        printf("%d\n",ans);
    }
}

 按理说dp都没啥模板，但是其实树上dp+背包，如果不复杂的化，也有点按部就班的感觉了～下次想出状态，寻轨道距应该就能做出来了。