动态规划-树形DP

关于树形DP这个东西，其实就是在树形结构上实现动态规划这个玩意。动态规划自然是多阶段决策问题，正好树的结构有明显的层次，一般对于树形DP利用深度优先搜索来操作。

（1）基础idea

分析：

eg对于样例这个图，我大致画一下(快乐指数就不画了，毕竟样例都是1)

假设以1为根节点，且1为第1层，那么答案很明显，就是 第一层+第三层+第五层的快乐值总和，这很明显，那么我们如何考虑别的情况呢？

如果直接一脑子考虑，哈哈，估计脑子会炸，毕竟这不是数学公式，我们不可能通过一个简单的推导就得到结果。万幸的是这是编程，可以通过模拟来解决问题，我们只需要一个结果，而不需要对一堆数字来得出一个证明。

对于每一个节点，他有两种情况，取和不取。

不妨大胆想象一下，如果对于这个节点，取的话，那么对于他的直接子节点而言，那肯定只能放弃了。如果对于这个节点，不取的话，那么对于他的直接子节点而言，肯定是从取和不取之间选一个开心值最大的。

文字思路上有了，那么如何实现呢？

首先，我们要知道，这是一个树结构，我们有一种算法，就是从根部遍历得到顶部（DFS），所以我们可以利用DFS这个算法，从底部到根部不断更新当前最优的答案，然后得到结果。

假设 dp【i】【0】为对于第i个节点而言不取的最大开心值，那么dp【i】【1】就设为对于第i个节点而言取的最大开心值。

设j为i的直接子节点，那么对于dp【i】【0】而言，dp【i】【0】=max(dp【j】【0】,dp【j】【1】)，对于dp【i】【1】而言，dp【i】【1】=dp【j】【0】+h【i】。

思路有了，上代码：

#include<vector>
using namespace std;
const int N=1e5+10;
#define ps push_back
int dp[N][2];
//1代表选择，0代表不选
int n,h[N];
vector<int> eg[N];
int root;
bool st[N];

void dfs(int u){
    dp[u][1]+=h[u];
    for(auto v:eg[u]){
        dfs(v);
        dp[u][0]+=max(dp[v][1],dp[v][0]);
        dp[u][1]+=dp[v][0];
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)
    cin>>h[i];
    
    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        eg[b].ps(a);
        st[a]=true;
    }//构造一棵树
    root=1;//根节点
    while(st[root]){
        root++;
    }//根节点肯定只和一个点连线
    dfs(root);
    cout<<max(dp[root][0],dp[root][1]);
    return 0;
}

有了这道题之后，接下来点差不多难度的idea练一练手吧，以下题目的idea我会在之后的博客中发布，求一波支持与关注，谢谢你

Party at Hali-Bula - HDU 2412 - Virtual Judge (vjudge.net)

Strategic game - POJ 1463 - Virtual Judge (vjudge.net)

Another Crisis - UVA 12186 - Virtual Judge (vjudge.net)

Perfect Service - UVA 1218 - Virtual Judge (vjudge.net)

（2）进阶版idea

eg1:

The more, The Better - HDU 1561 - Virtual Judge (vjudge.net)

分析：

这道题的idea一看，攻克某个城堡之前需要攻克之前的城堡，然后0代表可以直接攻克，这是什么？

冷静的考虑一下，这个结构其实就上以0为根节点，然后往下延伸的一棵树罢了，我们想解决一个问题，首先需要了解这个问题是什么，这棵树有个特点，就是你从0往下走的时候，会进行一次选择（这个选择是必须的），然后你可以回到任何你选择过的点继续往下走（当然也包括你刚刚走过的那个点），你最多有M次选择

好了，题目的大意了解清楚了，接下来就是怎么写了。

不要着急，这道题仔细想一想，M种选择，最大价值，是不是联想到了什么？对，这是一道背包问题，只不过我们将它转化到树上去操作。

那么我们如何操作呢？仔细想一想，我们是从根节点0开始出发，那么我们需要得到的就是从0开始出发，然后访问了M个城堡的最大值，而这个值又可以通过根节点来得到，代代传下去，其实就是通过DFS来不断向下搜的过程。

文字说了这么多，代码如何实现呢？

我们不妨假设dp【i】【j】为 以第i个城堡为根节点，往下走搜刮了j个城堡的最大价值，假设i的子节点为v，那么

dp【i】【j】=max（dp【i】【j】，dp【i】【j-k】+dp【v】【k】）其中k代表以第v个城堡为根节点，往下走搜刮了k个城堡的最大价值

具体代码如下：

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=210;
ll dp[N][N],h[N];
vector<int>eg[N];
int n,m;

void init(){//记得初始化
    for(int i=0;i<=n;i++)
    eg[i].clear();
    memset(dp,0,sizeof(dp));
}

void dfs(int u){
    dp[u][1]=h[u];
    for(int i=0;i<eg[u].size();i++){
        int v=eg[u][i];
        dfs(v);
        for(int j=m;j>=1;j--)
            for(int k=1;k<j;k++)
            dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]);
    }
}

void solve(){
    for(int i=1;i<=n;i++){
        int u,w;
        cin>>u>>w;
        h[i]=w;
        eg[u].push_back(i);
    }
    int root=0;
    m++;//很简单，因为对于第0个城堡，你肯定得选择
    dfs(root);
    cout<<dp[0][m]<<endl;
}

int main(){
    while(1){
        cin>>n>>m;
        if(n==0&&m==0)
        break;
        init();
        solve();
    }
    return 0;
}

哦，对了，关于这道题他有一个简称，叫树形背包DP（其实不重要，只要会idea就行）

有关例题：（这道题目的idea我会在之后的博客中发布，求一波支持与关注，谢谢你）

​​​​​​Apple Tree - POJ 2486 - Virtual Judge (vjudge.net)

eg2：

分析：

关于这道题，我们考虑一下，对于一棵树而言，他肯定有一种从上到下的结构，对于这个结构的每一个节点 u ，我们可以有以下两种情况。

（1）往下走最远

（2）往上走最远

对于往下走而言好说，直接自底部向上DFS遍历即可，但对于往上走而言，我们无法直接解决，不妨换个思路想一想，假设想求节点u向上走最远，假设v是u的父节点，那么向上的操作肯定和v有关系，而对于v来说，可以向下走非u的子节点使u最长，也可以向上走使u最长。

最后二者取最大值即可

代码：

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
typedef long long ll;
typedef pair<int,ll>PII;
const int N=1e4+100;
#define x first
#define y second
int n;
int root=1;
vector<PII> eg[N];
int num[N];
ll d1[N],d2[N],d3[N];
int idx[N];
ll dfs_up(int u,int fa){
    for(int i=0;i<eg[u].size();i++){
        int v=eg[u][i].x,w=eg[u][i].y;
        if(v==fa)
        continue;
        w=w+dfs_up(v,u);
        if(w>d1[u]){
            idx[u]=v;
            d2[u]=d1[u];
            d1[u]=w;
        }else if(w>d2[u])
            d2[u]=w;
    }
    return d1[u];
}

void dfs_down(int u,int fa){
    for(int i=0;i<eg[u].size();i++){
        int v=eg[u][i].x,w=eg[u][i].y;
        if(v==fa)
        continue;
        if(idx[u]==v)
        d3[v]=max(d3[u],d2[u])+w;
        else
        d3[v]=max(d3[u],d1[u])+w;
        dfs_down(v,u);
    }
}

int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int a,b;
        ll w;
        cin>>a>>b>>w;
        eg[a].push_back({b,w});
        eg[b].push_back({a,w});
        num[a]++;
        num[b]++;
    }
    while(num[root]!=1)
    root++;
    dfs_up(root,0);
    dfs_down(root,0);
    ll ans=1e18;
    for(int i=1;i<=n;i++)
    ans=min(ans,max(d1[i],d3[i]));
    cout<<ans<<endl;
    return 0;
}