【DP学习总结】树形DP

本文详细介绍了树形动态规划的两种类型:有根树的普通DP和树上背包DP,通过六个经典例题展示了如何在有上司的舞会、战略游戏、选课、有依赖的背包、计算机节点保护及翻转树边等问题中运用这一技术。从定义状态、状态转移方程到代码实现,深入浅出地展示了动态规划在树形结构中的应用技巧。
摘要由CSDN通过智能技术生成

本文参照:OI Wiki 树形DP

树形DP,顾名思义就是在树上进行的DP。我把它分为两类,1. 有根树, 2. 无根树
有根树又分为两种,一种是普通的DP,一种是树上背包DP。接下来,就来以此介绍

【例题1】没有上司的舞会

题目链接:P1352
题意: 有编号为 1 ∼ N 1 \sim N 1N N N N个职员,他们之间的关系就是一棵有根树,父节点是子节点的上司。他们将要举办舞会,每个人都有一个开心值 v a l i val_i vali。如果邀请了第 i i i个人的上司来,那么这第 i i i个人就不会来了。请你思考要邀请哪些人,是的开心值最大,并求出这个最大值。

Solution: 究极经典的树形DP了。
定义: f [ i ] [ 0 / 1 ] f[i][0/1] f[i][0/1]表示以 i i i为根节点的子树,0表示不邀请 i i i,1表示邀请 i i i所有得到的最大开心值
状态转移: 对于节点 u u u,有 u → v u \to v uv,设 V V V是所有 v v v的集合
f [ u ] [ 0 ] = ∑ v ∈ V m a x f [ v ] [ 0 ] , f [ v ] [ 1 ] f[u][0] = \sum_{v \in V} max{f[v][0], f[v][1]} f[u][0]=vVmaxf[v][0],f[v][1](上司不参加,那下属可以参加也可以不参加)
f [ u ] [ 1 ] = ∑ v ∈ V f [ v ] [ 0 ] f[u][1] = \sum_{v \in V} f[v][0] f[u][1]=vVf[v][0](上司参加,那下属不可以参加)

Code:

#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
constexpr int N = 6060;

vector<int> G[N];
int f[N][2], n, w[N];
bool vis[N];

void dfs(int u) {
    f[u][1] = w[u];
    f[u][0] = 0;
    for (int x : G[u]) {
        dfs(x);
        f[u][0] += max(f[x][0], f[x][1]);
        f[u][1] += f[x][0];
    }
}

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    cin >> n;
    for (int i = 1; i <= n; ++ i) cin >> w[i];
    for (int i = 1; i < n; ++ i) {
        int u, v;
        cin >> u >> v;
        vis[u] = true;
        G[v].push_back(u);
    }
    int root = 1;
    while (vis[root]) root ++;

    dfs(root);
    cout << max(f[root][0], f[root][1]) << "\n";
    return 0;
}

【例题2】Strategic game

题目链接:POJ 1463
题意: 大致题意应该是,有一个 N N N个节点 m − 1 m - 1 m1条边的有向图。你可以在 u u u这个节点放置一个士兵,这个士兵可以看守到所有的 u → v u \to v uv。问最少需要多少个士兵能看到所有的边。
Solution: 和上题差不多。
定义: f [ u ] [ 0 / 1 ] f[u][0/1] f[u][0/1]表示看到 u u u为根节点的子树,0表示不放士兵,1表示放置士兵 所需要的最少士兵数
状态转移: f [ u ] [ 0 ] = ∑ v ∈ V m i n ( f [ v ] [ 0 ] f [ v ] [ 1 ] ) f [ u ] [ 1 ] = ∑ v ∈ V f [ v ] [ 1 ] f[u][0] = \sum_{v \in V} min(f[v][0] f[v][1]) \\ \qquad \qquad f[u][1] = \sum_{v \in V} f[v][1] f[u][0]=vVmin(f[v][0]f[v][1])f[u][1]=vVf[v][1]

Code:

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
const int N = 1555;
vector<int> G[N];
int f[N][2];

void dfs(int u, int fa) {
    f[u][1] = 1;
    for (int i = 0; i < G[u].size(); ++ i) {
        int x = G[u][i];
        if(x == fa) continue;
        dfs(x, u);
        f[u][1] += min(f[x][0], f[x][1]);
        f[u][0] += f[x][1];
    }
}

int main() {
    int n;
    while (scanf("%d", &n) != EOF) {
        int root = -1;
        for (int i = 0; i <= n; i ++) G[i].clear(), f[i][0] = f[i][1] = 0; 
        for (int i = 1; i <= n; i ++) {
            int a, b;
            scanf("%d:(%d)", &a, &b);
            if(root == -1) root = a;
            for (int j = 1; j <= b; j ++) {
                int x; cin >> x;
                G[a].push_back(x);
                if(x == root) root = a;
            }
        }
        dfs(root, -1);
        printf("%d\n", min(f[root][1], f[root][0]));
    }    
    return 0;
}

【例题3】选课

题目链接:P2014
题意:
现在有 N N N门课程,第 i i i门课程的学分为 a i a_i ai,每门课程有零门或一门先修课,有先修课的课程需要先学完其先修课,才能学习该课程。

一位学生要学习 m m m门课程,求其能获得的最多学分数。

Solution:
根据先行课的特点,我们可以把这几门课看成森林,可以增加一个虚节点0为所有课程的先行课程。那就变成了一个以0为根节点的树结构。
这样的话,可以定义 f [ i ] [ j ] f[i][j] f[i][j]表示以 i i i为根节点的子树,选了 j j j节课的所有方案能得到的最多学分数。具体状态转移见代码
Code:

#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
constexpr int N = 303;
vector<int> G[N];
int w[N], n, m;
int f[N][N];

void dfs(int u) {
    for (int x : G[u]) {
        dfs(x); 
        // 开始分组背包, 有G[u].size()个组
        for (int i = m - 1; i >= 0; -- i) { // 注意是逆序 
            for (int j = 0; j <= i; ++ j) { 
                f[u][i] = max(f[u][i], f[u][i - j] + f[x][j]);
            } 
        }
    }
    // 前面处理完了子树,现在需要加上自己
    for (int i = m; i ; -- i)
        f[u][i] = f[u][i - 1] + w[u];
}
 
int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1; i <= n; ++ i) {
        int x, y; cin >> x >> y;
        w[i] = y;
        G[x].push_back(i);
    }
    m ++;
    dfs(0);
    cout << f[0][m] << "\n";
    return 0;
}

【例题4】有依赖的背包问题

题目链接:Acwing10

题意:
在这里插入图片描述
Solution
定义: f [ i ] [ j ] f[i][j] f[i][j]表示以 i i i为根节点的子树,体积为 j j j的所有方案中的最大价值。
Code:

#include <bits/stdc++.h>
using namespace std;

const int N = 110;

vector<int> G[N];
int f[N][N], v[N], w[N], n, m;

void dfs(int u) {
    
    for(int x : G[u]) {
        dfs(x);
        for(int j = m - v[u]; j >= 0; -- j)
            for(int k = 0; k <= j; ++ k)
                f[u][j] = max(f[u][j], f[u][j - k] + f[x][k]);
    }
    
    for(int j = m; j >= v[u]; -- j) f[u][j] = f[u][j - v[u]] + w[u];
    for(int j = 0; j < v[u]; ++ j ) f[u][j] = 0; 
}

int main()
{
    cin >> n >> m;
    int root, p;
    for(int i = 1; i <= n; ++ i) {
        cin >> v[i] >> w[i] >> p;
        if(p == -1) root = i;
        else G[p].push_back(i);
    }
    dfs(root);
    cout << f[root][m] << "\n";
    return 0;
}

【例题5】Computer

题目链接:HDU 2196
题意: n n n个电脑, n − 1 n-1 n1条边, 每条边有一个权值。问距离 1 ∼ n 1 \sim n 1n节点最远的距离是多少?
Solution:

引理: 以 u u u为根节点的树, 距离 u u u的最远距离和次远距离一定在两颗子树当中.

对于此题定义: f [ u ] [ 0 / 1 / 2 ] f[u][0 / 1/ 2] f[u][0/1/2]分别表示, 以 u u u为根节点, 往下距离 u u u的最远距离,往下距离 u u u的次远距离,往上走的最远距离. 那么最后的答案就是 m a x ( f [ i ] [ 0 ] , f [ i ] [ 2 ] ) max(f[i][0], f[i][2]) max(f[i][0],f[i][2])
状态转移:
f [ u ] [ 0 / 1 ] f[u][0/1] f[u][0/1]可以用一个dfs自下而上更新
对于 f [ u ] [ 2 ] f[u][2] f[u][2], 需要自上而下更新. 考虑 u → v u \to v uv这边, 如果 f [ v ] [ 0 ] + v a l = = f [ u ] [ 0 ] f[v][0] + val == f[u][0] f[v][0]+val==f[u][0]说明距离 u u u最远的节点在这课子树当中, 不能用起更新, 要用次远距离更新. 具体细节看代码
Code:

#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
constexpr int N = 10010;
vector<PII> G[N];
int f[N][3], n;

void dfs1(int u, int fa) {
    int d1, d2; d1 = d2 = 0;
    for (auto x : G[u]) {
        int ver = x.first, w = x.second;
        if(ver == fa) continue;
        dfs1(ver, u);
        int d = f[ver][0] + w;
        if(d > d1) d2 = d1, d1 = d;
        else if(d > d2) d2 = d;
    }
    f[u][0] = d1; f[u][1] = d2;
}

void dfs2(int u, int fa) {
    for (auto x : G[u]) {
        int ver = x.first, w = x.second;
        if(ver == fa) continue;
        if (f[ver][0] + w == f[u][0]) { // 最远距离为该子树,用次远距离更新
            f[ver][2] = max(f[u][2], f[u][1]) + w;
        } else {
            f[ver][2] = max(f[u][2], f[u][0]) + w;
        }
        dfs2(ver, u);
    }
}

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    while (cin >> n) {
        for (int i = 1; i <= n; i++) {
            G[i].clear();
            for (int j = 0; j < 3; j ++) f[i][j] = 0;
        }
        for (int i = 2; i <= n; i ++) {
            int a, b; cin >> a >> b;
            G[i].push_back({a, b});
            G[a].push_back({i, b});
        }
        dfs1(1, 0);
        dfs2(1, 0);
        for (int i = 1; i <= n; i ++) cout << max(f[i][0], f[i][2]) << "\n";
    }
    return 0;
}

【例题6】[POI2008] STA-Station

题目链接: P3478
题意: 给定一个 n n n个点的树,请求出一个结点,使得以这个结点为根时,所有结点的深度之和最大。
Solution:
先用一个dfs1求出每个节点的 d e p i dep_i depi(距离根节点的深度)和 s z i sz_i szi(该节点的子树大小)
ps: 注意这里所谓的根节点假设为1, 这是一颗无根树
f [ i ] f[i] f[i]表示答案. 依旧考虑 u → v u \to v uv这条边, f [ u ] f[u] f[u]是已知的, 将根换到 v v v后,会减少了 s z v sz_v szv, 会增加 n − s z i n - sz_i nszi也就是 f [ v ] = f [ u ] + n − 2 ∗ s z i f[v] = f[u] + n - 2 * sz_i f[v]=f[u]+n2szi

Code:

#include <bits/stdc++.h>
#define debug(x) cerr << #x << " = " << x << "\n"
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
constexpr int N = 1000010;
vector<int> G[N];
LL dep[N], sz[N], f[N], n;

void dfs1(int u, int fa) {
    sz[u] = 1;
    dep[u] = dep[fa] + 1;
    for (auto x : G[u]) {
        if(x == fa) continue;
        dfs1(x, u);
        sz[u] += sz[x];
    }
}

void dfs2(int u, int fa) {
    for (int x : G[u]) {
        if(x == fa) continue;
        f[x] = f[u] + n - 2 * sz[x];
        dfs2(x, u);
    }
}

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    cin >> n;
    for (int i = 1; i < n; i ++) {
        int u, v; cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dep[0] = -1;
    dfs1(1, 0);
    for (int i = 1; i <= n; i ++) f[1] += dep[i];
    dfs2(1, 0);
    LL ans = -1, id;
    for (int i = 1; i <= n; i ++) {
        if(f[i] > ans) {
            ans = f[i];
            id = i;
        }
    }
    cout << id << "\n";
    return 0;
}

【例题7】翻转树边

题目链接:Acwing 4381
给定一个 n 个节点的树。
节点编号为 1∼n。

树中的 n−1 条边均为单向边。

现在,我们需要选取一个节点作为中心点,并希望从中心点出发可以到达其他所有节点。

但是,由于树中的边均为单向边,所以在选定中心点后,可能无法从中心点出发到达其他所有节点。

为此,我们需要翻转一些边的方向,从而使得所选中心点可以到达其他所有节点。

我们希望选定中心点后,所需翻转方向的边的数量尽可能少。

请你确定哪些点可以选定为中心点,并输出所需的最少翻转边数量。

Solution:
正向边权值0,反向边权值1, 以1为根节点
f[i]表示以i为根节点的子树所需要翻转的数量
dp[i]表示以i为中心点需要翻转的数量
由下到上更新f[]
由上到下更新dp[](考虑 u → v u \to v uv这条边时,如果权值为0, d p [ v ] = d p [ u ] + 1 dp[v] = dp[u] + 1 dp[v]=dp[u]+1,如果权值为1, d p [ v ] = d p [ u ] − 1 dp[v] = dp[u] - 1 dp[v]=dp[u]1;

Code

#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using LL = long long;
typedef pair<int, int> PII;
template < typename T> inline void Max(T &a, T b) { if(a < b) a = b; }
template < typename T> inline void Min(T &a, T b) { if(a > b) a = b; }
constexpr int N = 2e5 + 10;
int n;
vector<PII> G[N];
int f[N], dp[N];

void dfs1(int u, int fa) {
    for (auto it : G[u]) {
        if(it.first == fa) continue;
        dfs1(it.first, u);
        f[u] += f[it.first] + it.second;
    }
}

void dfs2(int u, int fa) {
    for (auto it : G[u]) {
        if(it.first == fa) continue;
        dp[it.first] = dp[u] + (it.second == 1 ? -1 : 1);
        dfs2(it.first, u);
    }
} 


int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    cin >> n;
    for (int i = 1; i < n; i ++ ) {
        int a, b;
        cin >> a >> b;
        G[a].push_back({b, 0});
        G[b].push_back({a, 1});
    }
    dfs1(1, 0);
    dp[1] = f[1];
    dfs2(1, 0);
    int ans = 1 << 30;
    for (int i = 1; i <= n; i ++ ) Min(ans, dp[i]);
    cout << ans << "\n";
    for (int i = 1; i <= n; i ++ )
        if(dp[i] == ans) 
            cout << i << " ";
    return (0-0);
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

W⁡angduoyu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值