UVA - 1407 Caves 树形dp 多重背包

分析

参考：https://www.jianshu.com/p/065cfa72e24b
状态的定义比较明显，主要是状态转移部分有点复杂，差点被绕晕了，现在觉得类似于多重背包问题

//0-1背包的枚举物品
    for(int i=0;i<g[node].size();++i){
        pair<int,int> &temp=g[node][i];
        //为了放置重复计算，j从大到小进行更新
        for(int j=tot[node];j>=2;--j)

第一个是三重循环，第一重便利物品，第二重从大到小遍历点数，一定要从大到小，不能反过来，放置重复遍历一个子树，第三重就是每个子树的遍历点数，三重循环顺序不能改变

dp[node][j][0]=min(dp[node][j][0],dp[node][j-k][0]+dp[temp.first][k][0]+((temp.second)<<1));
dp[node][j][1]=min(dp[node][j][1],dp[node][j-k][0]+dp[temp.first][k][1]+temp.second);
dp[node][j][1]=min(dp[node][j][1],dp[node][j-k][1]+dp[temp.first][k][0]+((temp.second)<<1));

第二个是状态转移，状态1有两种方式转移，一种是temp.first子树是1，不返回，另外一种是temp.first子树是0，返回

代码

//参考：https://www.jianshu.com/p/065cfa72e24b
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
const int maxn=500+5,Inf=0x3f3f3f3f;

//dp[i][j][2],以i为根的子树中走过k个节点的最小费用，dp[i][j][0]代表最后回到i点，dp[i][j][1]代表子厚不会到i点
//dp[i][j][2]不能使用dp[i][j]，必须使用一个维度记录是否回归，不能用dp[i][j][1]的最小值中的距离i最近的停留点计算
//dp[i][j][1]
int n,a,b,c,q,x,dp[maxn][maxn][2],fa[maxn],root,tot[maxn],ans,res[maxn],kase=0;
vector<pair<int,int>> g[maxn];

void dfs(int node){
    tot[node]=1;
    for(int i=0;i<g[node].size();++i){
        dfs(g[node][i].first);
        tot[node]+=tot[g[node][i].first];
    }
    dp[node][1][0]=dp[node][1][1]=0;
    //类似于优化空间后的0-1背包的做法，先将答案的数组初始化为Inf
    for(int i=2;i<=tot[node];++i){
        dp[node][i][0]=dp[node][i][1]=Inf;
    }
    //0-1背包的枚举物品
    for(int i=0;i<g[node].size();++i){
        pair<int,int> &temp=g[node][i];
        //为了放置重复计算，j从大到小进行更新
        for(int j=tot[node];j>=2;--j) {
            for(int k=tot[temp.first];k>=1;--k){
                if(j-k<1) continue;
                dp[node][j][0]=min(dp[node][j][0],dp[node][j-k][0]+dp[temp.first][k][0]+((temp.second)<<1));
                dp[node][j][1]=min(dp[node][j][1],dp[node][j-k][0]+dp[temp.first][k][1]+temp.second);
                dp[node][j][1]=min(dp[node][j][1],dp[node][j-k][1]+dp[temp.first][k][0]+((temp.second)<<1));
            }
        }
    }
}

int main(void){
    while(scanf("%d",&n)==1 && n){
        memset(fa,-1,sizeof(fa));
        memset(tot,0,sizeof(tot));
        for(int i=0;i<=n;++i) g[i].clear();
        for(int i=1;i<n;++i){
            scanf("%d%d%d",&a,&b,&c);
            fa[a]=b;
            g[b].emplace_back(a,c);
        }
        root=0;
        while(fa[a]!=-1){
            a=fa[a];
            root=a;
        }
        dfs(root);
        res[0]=res[1]=0;
        for(int i=2;i<=tot[root];++i)
            res[i]=dp[root][i][1];
        scanf("%d",&q);
        printf("Case %d:\n",++kase);
        for(int i=0;i<q;++i){
            scanf("%d",&x);
            ans=upper_bound(res,res+tot[root]+1,x)-res;
            printf("%d\n",ans-1);
        }
    }
    return 0;
}