树形dp系列

1072. 树的最长路径

题目链接

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 10010, M = N * 2;

int n;
int h[N], e[M], w[M], ne[M], idx;
int ans;

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int dfs(int u, int father) {
    int dist = 0;  // 表示从当前点往下走的最大长度
    int d1 = 0, d2 = 0;

    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (j == father)
            continue;
        int d = dfs(j, u) + w[i];
        dist = max(dist, d);

        if (d >= d1)
            d2 = d1, d1 = d;
        else if (d > d2)
            d2 = d;
    }

    ans = max(ans, d1 + d2);

    return dist;
}

int main() {
    cin >> n;

    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }

    dfs(1, -1);

    cout << ans << endl;

    return 0;
}

题解：就是树形dp，把每个点的能延伸出去的路径上找出最长的两条路径相加之和就是答案

树的中心

题目链接

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;

int n;
int h[N], e[M], w[M], ne[M], idx;
int d1[N], d2[N], p1[N], up[N];
bool is_leaf[N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int dfs_d(int u, int father) {
    d1[u] = d2[u] = -INF;
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (j == father)
            continue;
        int d = dfs_d(j, u) + w[i];
        if (d >= d1[u]) {
            d2[u] = d1[u], d1[u] = d;
            p1[u] = j;
        } else if (d > d2[u])
            d2[u] = d;
    }

    if (d1[u] == -INF) {
        d1[u] = d2[u] = 0;
        is_leaf[u] = true;
    }

    return d1[u];
}

void dfs_u(int u, int father) {
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (j == father)
            continue;

        if (p1[u] == j)
            up[j] = max(up[u], d2[u]) + w[i];
        else
            up[j] = max(up[u], d1[u]) + w[i];

        dfs_u(j, u);
    }
}

int main() {
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }

    dfs_d(1, -1);
    dfs_u(1, -1);

    int res = d1[1];
    for (int i = 2; i <= n; i++)
        if (is_leaf[i])
            res = min(res, up[i]);
        else
            res = min(res, max(d1[i], up[i]));

    printf("%d\n", res);

    return 0;
}

题解：先向下进行搜索，找出向下走的最远距离，再向上搜索，找出向上走的最远距离。

1075. 数字转换

题目链接

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 50010, M = N;

int n;
int h[N], e[M], w[M], ne[M], idx;
int sum[N];
bool st[N];
int ans;

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int dfs(int u) {
    st[u] = true;

    int dist = 0;
    int d1 = 0, d2 = 0;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (!st[j]) {
            int d = dfs(j);
            dist = max(dist, d);
            if (d >= d1)
                d2 = d1, d1 = d;
            else if (d > d2)
                d2 = d;
        }
    }

    ans = max(ans, d1 + d2);

    return dist + 1;
}

int main() {
    cin >> n;
    memset(h, -1, sizeof h);

    for (int i = 1; i <= n; i++)
        for (int j = 2; j <= n / i; j++)
            sum[i * j] += i;

    for (int i = 2; i <= n; i++)
        if (sum[i] < i)
            add(sum[i], i);

    for (int i = 1; i <= n; i++)
        if (!st[i])
            dfs(i);

    cout << ans << endl;

    return 0;
}

题解：就是转换成树的最长路径

1074. 二叉苹果树

题目链接

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 110, M = N * 2;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int f[N][N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u, int father) {
    for (int i = h[u]; ~i; i = ne[i]) {
        if (e[i] == father)
            continue;
        dfs(e[i], u);
        for (int j = m; j; j--)
            for (int k = 0; k + 1 <= j; k++)
                f[u][j] = max(f[u][j], f[u][j - k - 1] + f[e[i]][k] + w[i]);
    }
}

int main() {
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }

    dfs(1, -1);

    printf("%d\n", f[1][m]);

    return 0;
}

题解：这里是用了分组背包+依赖背包（树形dp）的思想去解答问题的。

323. 战略游戏

题目链接

#include <bits/stdc++.h>
using namespace std;
const int N = 1510, M = N * 2;

int n;
int h[N], e[M], ne[M], idx;
int f[N][2];
int st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void dfs(int u) {
    f[u][1] = 1, f[u][0] = 0;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        dfs(j);
        f[u][1] += min(f[j][0], f[j][1]);
        f[u][0] += f[j][1];
    }
}
int main() {
    while (scanf("%d", &n) != -1) {
        memset(h, -1, sizeof(h));
        memset(st, 0, sizeof(st));
        idx = 0;
        while (n--) {
            int a, b;
            scanf("%d:(%d)", &a, &b);
            while (b--) {
                int c;
                scanf("%d", &c);
                add(a, c);
                st[c] = 1;
            }
        }
        int root = 0;
        while (st[root])
            root++;
        dfs(root);
        printf("%d\n", min(f[root][0], f[root][1]));
    }

    return 0;
}

题解：就是普通的树形dp，和没有上司的舞会差不多

1077. 皇宫看守

题目链接

#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 1510;

int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u) {
    f[u][2] = w[u];

    int sum = 0;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        dfs(j);
        f[u][0] += min(f[j][1], f[j][2]);
        f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
        sum += min(f[j][1], f[j][2]);
    }

    f[u][1] = 1e9;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        f[u][1] = min(f[u][1], sum - min(f[j][1], f[j][2]) + f[j][2]);
    }
}

int main() {
    cin >> n;

    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i++) {
        int id, cost, cnt;
        cin >> id >> cost >> cnt;
        w[id] = cost;
        while (cnt--) {
            int ver;
            cin >> ver;
            add(id, ver);
            st[ver] = true;
        }
    }

    int root = 1;
    while (st[root])
        root++;

    dfs(root);

    cout << min(f[root][1], f[root][2]) << endl;

    return 0;
}

题解：这里的树形dp有三个状态，f[u][0]是指当前结点u没有守卫，但是父节点有守卫，f[u][1]是指当前结点u没有守卫，但是其中一个子节点有守卫；f[u][2]是指当前结点有守卫，周围结点随意。和前面战略游戏不同的是，当前结点没有守卫的话，不需要子节点和父节点都有守卫，只要其中一个有就行，这一点有很大的不同。

164. 可达性统计

题目链接

#include <bits/stdc++.h>
using namespace std;
const int N = 3e4+10;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int q[N], sum[N], d[N];
bitset<N> f[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void topsort() {
    int tt = -1, hh = 0;
    for (int i = 1; i <= n; ++i) {
        f[i][i] = 1;
        if (d[i] == 0)
            q[++tt] = i;
    }

    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            f[j] |= f[t];
            if (--d[j] == 0) {
                q[++tt] = j;
            }
        }
    }
}

int main() {
    cin >> n >> m;
    memset(h, -1, sizeof(h));
    while (m--) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);
        d[a]++;
    }
    topsort();
    for (int i = 1; i <= n; ++i)
        cout << f[i].count() << endl;
    return 0;
}

题解：这里因为点比较多，有30000个，无法正常用数组记录状态，这就用到了状态压缩。根据y总的说法用了一个bitset集合，这是一个全部都是存储二进制的集合，可以开到30000的容量，用f[u]的每一个位来表示数字u是否可以到达该位上面。