当前位置：首页 > news >正文

CSP-J/S 复赛算法树形动态规划

news 来源：原创 2025/5/13 0:01:00

文章目录

前言
树形动态规划
- - 区别：树形动态规划 vs 线性动态规划
  - 举例说明：
  - - 例子中的图解：
  - 总结：
应用场景
- 1. **树上的最大权独立集**
- 2. **树的直径问题**
- 3. **树上的最小覆盖问题**
示例代码
- 1. 树上的最大权独立集
- 2. 树的直径问题
- 3. 树上的最小覆盖问题
- - 代码说明：
总结

前言

树形动态规划是一种专门用于树结构上求解最优化问题的技术，广泛应用于计算机科学中的多个领域。在CSP-J/S复赛的算法题中，树形动态规划常常被用来解决与树结构相关的复杂问题，如路径最大化、节点选择、覆盖问题等。与线性动态规划相比，树形动态规划具有更高的灵活性和适应性，能够有效地处理具有层次关系的复杂数据结构。

树形动态规划的核心思想在于通过递归或深度优先搜索（DFS）的方法，从树的叶子节点开始逐层计算，利用子节点的最优解逐步推导出父节点的最优解。通过这种方式，我们可以将大问题分解为多个小问题，从而更高效地求解整体问题。

在这篇文章中，我们将深入探讨树形动态规划的基本原理、常见应用以及在CSP-J/S复赛中如何灵活运用这一技术，帮助我们更好地应对比赛中的算法挑战。

树形动态规划

树形动态规划的通俗介绍

树形动态规划（Tree DP）是一种专门用于树形结构（比如一棵二叉树或者多叉树）上的动态规划方法。与我们常见的线性动态规划不同，线性DP通常用于处理一维的序列，比如从左到右计算数组中的最优解。而树形DP要处理的是多层次、分支结构的问题，每个节点不仅要考虑自身，还要考虑与它相连的多个子节点的关系。

树形动态规划的核心思想：

每个节点就是树上的一个状态
通过递归的方式从叶子节点（没有子节点的节点）逐步计算其父节点的最优解
每个节点的最优解，通常是根据它的子节点的最优解来推导的

区别：树形动态规划 vs 线性动态规划

结构不同：
- 线性动态规划：用于处理一维的线性结构，比如数组。
- 树形动态规划：用于处理树形结构的问题，树状结构通常有分支和层次，复杂度更高。
状态转移不同：
- 线性动态规划：状态之间是相邻的，比如从前一个状态转移到下一个状态。
- 树形动态规划：状态之间的转移通常涉及多个子节点到父节点的聚合过程。
遍历方式不同：
- 线性动态规划：常常是按顺序遍历或倒序遍历。
- 树形动态规划：常用的遍历方式是深度优先遍历（DFS），从叶子节点开始，逐步往上计算父节点的状态。

举例说明：

假设我们有一棵树，表示一个村庄系统，每个节点代表一个村子，每个村子可以选择修建一个设施（比如水井），但相邻的村子不能同时修设施，如何让村庄系统的设施最大化？

树形动态规划的思路是：从最底层的村子开始，计算在每个村子建不建设施时的最优解，递归往上计算父村子的选择。

例子中的图解：

树的结构：
- 每个圆圈代表一个村庄节点。
- 连接的线表示相邻的村子，不能同时建设施。

状态转移过程：
- 从最底层的节点（4, 5, 6）开始。
- 如果4建了设施，那么2就不能建设施，要根据这个信息来决定村庄1的状态。

总结：

线性动态规划适合解决线性序列问题，比如最短路径、背包问题。
树形动态规划适合解决树状结构的问题，比如在树状网络中找最优路径、村庄设施问题等。

通过理解这两种动态规划，能够灵活应对不同结构下的最优解问题。

应用场景

以下是三个常见的树形动态规划应用场景：

1. 树上的最大权独立集

问题描述：给定一棵树，每个节点上有一个权值，要求从这棵树中选择一些节点，满足选择的节点之间没有直接相连（即父子关系节点不能同时选中），使得被选中节点的权值和最大。
应用场景：比如在一个村庄系统中，每个村庄可以选择修建一个设施（如水井），但相邻的村子不能同时修建，求使村庄设施建设的总价值最大。
解题思路：对于每个节点，可以选择要么不选当前节点（那么它的子节点可以自由选择），要么选当前节点（那么它的子节点都不能被选）。通过递归从叶子节点开始，逐层计算最优解。

2. 树的直径问题

问题描述：给定一棵树，求树中两点之间的最长路径长度。这条最长路径叫做树的直径。
应用场景：比如通信网络中节点的最远距离，或者城市规划中确定相距最远的两个城市。
解题思路：使用树形动态规划的思想，从叶子节点开始计算每个节点的最长路径，递归往上层计算。树的直径可以通过在树中两次DFS（深度优先搜索）得到。

3. 树上的最小覆盖问题

问题描述：给定一棵树，要求选择最少的节点，使得这棵树的每条边至少有一个端点被选择，即覆盖整棵树。
应用场景：比如在传感器网络中，要布置最少的传感器，确保每条边上的节点至少有一个安装了传感器。
解题思路：对于每个节点，可以选择是否在它上面放置传感器。如果一个节点不放传感器，那么它的子节点一定要放。利用树形动态规划，递归计算每个节点是否放置传感器的最优解。

这三个例子展示了树形动态规划在不同问题中的应用，通过递归地处理子问题，从而解决树状结构中的全局最优问题。

示例代码

下面是三个树形动态规划问题的 C++ 代码示例。每个示例都不使用类，而是使用简单的函数和结构体。

1. 树上的最大权独立集

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Node {
    int weight;
    vector<int> children;
};

int dfsMaxWeightIndependentSet(Node nodes[], int u, bool parentIncluded) {
    if (parentIncluded) {
        // 如果父节点被包含，子节点不能被包含
        int totalWeight = 0;
        for (int child : nodes[u].children) {
            totalWeight += dfsMaxWeightIndependentSet(nodes, child, false);
        }
        return totalWeight;
    } else {
        // 选择包含当前节点或不包含
        int includeNode = nodes[u].weight; // 包含当前节点
        for (int child : nodes[u].children) {
            includeNode += dfsMaxWeightIndependentSet(nodes, child, true);
        }

        int excludeNode = 0; // 不包含当前节点
        for (int child : nodes[u].children) {
            excludeNode += dfsMaxWeightIndependentSet(nodes, child, false);
        }

        return max(includeNode, excludeNode);
    }
}

int main() {
    int n; // 节点数量
    cin >> n;

    Node nodes[n]; // 节点数组
    for (int i = 0; i < n; i++) {
        cin >> nodes[i].weight; // 输入节点的权值
    }

    // 输入树的结构
    // 假设树是以父子关系的方式给出的
    for (int i = 1; i < n; i++) {
        int parent;
        cin >> parent; // 输入父节点索引
        nodes[parent].children.push_back(i);
    }

    int maxWeight = dfsMaxWeightIndependentSet(nodes, 0, false);
    cout << "最大权独立集的权值和是: " << maxWeight << endl;

    return 0;
}

2. 树的直径问题

#include <iostream>
#include <vector>
using namespace std;

struct Node {
    vector<int> children;
};

int maxDepth(Node nodes[], int u, int &maxDiameter) {
    int max1 = 0, max2 = 0; // 前两大深度
    for (int child : nodes[u].children) {
        int depth = maxDepth(nodes, child, maxDiameter);
        if (depth > max1) {
            max2 = max1;
            max1 = depth;
        } else if (depth > max2) {
            max2 = depth;
        }
    }
    maxDiameter = max(maxDiameter, max1 + max2); // 更新直径
    return max1 + 1; // 返回当前节点的深度
}

int main() {
    int n; // 节点数量
    cin >> n;

    Node nodes[n]; // 节点数组
    for (int i = 1; i < n; i++) {
        int parent;
        cin >> parent; // 输入父节点索引
        nodes[parent].children.push_back(i);
    }

    int maxDiameter = 0;
    maxDepth(nodes, 0, maxDiameter); // 从根节点开始
    cout << "树的直径是: " << maxDiameter << endl;

    return 0;
}

3. 树上的最小覆盖问题

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Node {
    vector<int> children;
};

pair<int, int> dfsMinCover(Node nodes[], int u) {
    int includeNode = 1; // 包含当前节点
    int excludeNode = 0; // 不包含当前节点

    for (int child : nodes[u].children) {
        pair<int, int> childCover = dfsMinCover(nodes, child);
        includeNode += childCover.second; // 包含当前节点时，子节点可以不包含
        excludeNode += min(childCover.first, childCover.second); // 不包含当前节点时，子节点必须包含
    }

    return {includeNode, excludeNode};
}

int main() {
    int n; // 节点数量
    cin >> n;

    Node nodes[n]; // 节点数组
    for (int i = 1; i < n; i++) {
        int parent;
        cin >> parent; // 输入父节点索引
        nodes[parent].children.push_back(i);
    }

    pair<int, int> result = dfsMinCover(nodes, 0); // 从根节点开始
    int minCover = min(result.first, result.second); // 取最小值
    cout << "最小覆盖节点数量是: " << minCover << endl;

    return 0;
}