什么是树形DP？

1.什么是树形DP？

---

树形DP是一种利用树型结构进行动态规划的算法。它的基本思想是把树看作一个递归结构，先处理子树，再处理整个树。在树形DP中，我们通过定义状态和状态转移方程，来解决一些与树相关的问题，比如最长路径、最小路径覆盖等等。在实现上，通常采用 DFS 或者 BFS 的方式遍历整棵树，同时记录中间状态，避免重复计算。树形DP是一种高效的算法，常被用于解决树状结构问题，如图论、字符串、计算几何等领域。

2.用C++实现树形DP算法

---

1.

下面是两个 C++ 实现树形 DP 的例子，其中以计算以节点 1 为根节点的树的最长路径为例。

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

const int N = 1e5 + 5;

vector<int> G[N];
int n, root, ans = N;
int sz[N];

void dfs(int u, int fa) {
    sz[u] = 1;
    int res = 0;
    for (int v: G[u]) {
        if (v == fa) continue;
        dfs(v, u);
        sz[u] += sz[v];
        res = max(res, sz[v]);
    }
    res = max(res, n - sz[u]);
    if (res < ans) {
        ans = res;
        root = u;
    }
}

int main() {
    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);
    }
    dfs(1, 0);
    cout << root << endl;
    return 0;
}

在这个例子中，我们定义了一个 dp 数组，其中 dp[i] 表示以节点 i 为根的子树的最长路径。在遍历树时，我们递归处理每个子节点，并根据其子节点的 dp 值来更新当前节点的 dp 值。最终得到 dp[1] 即为以节点 1 为根节点的树的最长路径。

2.

下面是一个简单的树形DP算法示例，用C++实现，它解决的问题是对于一个有根树，计算树的重心和子树大小。

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

const int MAXN = 1005;

vector<int> G[MAXN];
int dp[MAXN];

// DFS 遍历树，计算以 root 为根的子树的最长路径
void dfs(int root, int fa) {
    dp[root] = 0;
    int max1 = 0, max2 = 0;
    for (int i = 0; i < G[root].size(); i++) {
        int son = G[root][i];
        if (son == fa) continue;
        dfs(son, root);
        int d = dp[son] + 1;
        if (d >= max1) {
            max2 = max1;
            max1 = d;
        } else if (d > max2) {
            max2 = d;
        }
    }
    dp[root] = max1 + max2; // 更新以 root 为根的子树的最长路径
}

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dfs(1, 0);
    cout << dp[1] << endl; // 输出计算结果
    return 0;
}

整个算法的核心是在 dfs 函数中进行计算。首先初始化当前节点的大小为1，表示节点本身的大小，然后遍历当前节点的所有孩子节点，并递归地计算它们的子树大小。最后，使用当前节点的子树大小和 n - sz[u] ，即除了当前节点子树以外的大小，比较出该节点的重心。

在上面的实现中，使用了一个 vector 数组来存储树边，方便遍历每个节点的邻居节点。在计算完成后，输出重心的编号即可。