树上覆盖集计数【树形动态规划】

最新推荐文章于 2025-05-28 11:47:39 发布

原创最新推荐文章于 2025-05-28 11:47:39 发布 · 456 阅读

1 ·

CC 4.0 BY-SA版权

树形动态规划专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种使用树形动态规划解决寻找树中最小覆盖集及其计数的方法。通过定义不同状态来覆盖所有可能的情况，并利用递归思想进行状态转移。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

给定一棵 $n$ 个节点的树，求它的最小覆盖集个数。

Solution

我们考虑同时维护节点的最小覆盖集和最小覆盖集个数。我们发现一个点被覆盖只有 $3$ 种情况：父亲被选入集合，自己被选入集合和至少一个儿子被选入集合。我们写出 $DP$ 状态：

⎧ ⎩ ⎨ ⎪ ⎪ f [u] [i] [0] 表 示 u 的 父 亲 被 选 入 集 合 ， 自 己 和 任 意 一 个 儿 子 不 被 选 入 集 合 f [u] [i] [1] 表 示 u 有 至 少 一 个 儿 子 被 选 入 集 合 f [u] [i] [2] 表 示 u 自 己 被 选 入 集 合

$\begin {cases} \ f[u][i][0]\ 表示\ u\ 的父亲被选入集合，自己和任意一个儿子不被选入集合 \\ \ f[u][i][1]\ 表示\ u\ 有至少一个儿子被选入集合 \\ \ f[u][i][2]\ 表示\ u\ 自己被选入集合 \end {cases}$

而 $g[u][i]$ 表示 $f[u][i]$ 情况下的方案数。

考虑转移 $f$ 。

{\begin{cases} f [u] [i] [0] = min_{v \in son (u)} f [v] [1] \\ f [u] [i] [1] = min_{v \in son (u)} f [v] [2] + \sum_{v^{'} \in son (u), v^{'} \neq v} m i n (f [v^{'}] [1], f [v^{'}] [2]) \\ f [u] [i] [2] = 1 + \sum_{v \in son (u)} {min}_{i = 0}^{2} f [v] [i] \end{cases}

$\begin {cases} \ f[u][i][0] = \min_{v \in \text {son}(u)} f[v][1] \\ \ f[u][i][1] = \min_{v \in \text {son}(u)} f[v][2] + \sum_{v' \in \text {son}(u),v' \ne v} min(f[v'][1], f[v'][2]) \\ \ f[u][i][2] = 1 + \sum_{v \in \text {son}(u)} \min_{i=0}^{2} f[v][i] \\ \end {cases}$

再转移 $g$ 。

首先转移 $g[0]$ 。我们发现父亲节点状态为 $0$ 时儿子节点状态必为 $1$ ，所以 $g[u][0] = \prod_{v \in \text {son}(u)}g[v][1]$

然后转移 $g[2]$ 。我们发现 $g[2]$ 的儿子可以随便选，所以只要用满足 $\min\ f[v][i]=f[v][k]$ 的 $k$ 更新即可。

最后转移 $g[1]$ 。我们发现 $f[u][1] = min(f[u][1] + min(f[v][1], f[v][2]), f[u][0] + f[v][2])$ 。于是使用这几种状态分别计算 $f[u][1]$ 是不是等于它，如果是就直接计算方案数即可。细节较多，这里不列举。详见代码。

Code

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

const int maxn = 1000005;
const int maxm = 2000005;
const int P = 1000000007;
int n, f[maxn][3], g[maxn][3];
int m, ter[maxm], nxt[maxm], lnk[maxn];
// 0: up, 1: down, 2: self;

void addedge(int u, int v) {
    ter[++m] = v;
    nxt[m] = lnk[u];
    lnk[u] = m;
}

void update(int &a, int b) {
    a += b, (a >= P) && (a -= P);
}

void dfs(int u, int p) {
    int t, mn;
    f[u][1] = n + 1, f[u][2] = g[u][0] = g[u][1] = g[u][2] = 1;
    for (int i = lnk[u]; i; i = nxt[i]) {
        int v = ter[i];
        if (v == p) continue;
        dfs(v, u);
        t = 0;
        mn = min(f[v][0], min(f[v][1], f[v][2]));
        if (f[v][0] == mn) update(t, g[v][0]);
        if (f[v][1] == mn) update(t, g[v][1]);
        if (f[v][2] == mn) update(t, g[v][2]);
        f[u][2] += mn;
        g[u][2] = 1ll * g[u][2] * t % P;
        t = 0;
        mn = min(f[u][1] + min(f[v][1], f[v][2]), f[u][0] + f[v][2]);
        if (f[u][1] + f[v][1] == mn) update(t, g[v][1]);
        if (f[u][1] + f[v][2] == mn) update(t, g[v][2]);
        f[u][1] = mn;
        g[u][1] = 1ll * t * g[u][1] % P;
        if (f[u][0] + f[v][2] == mn) update(g[u][1], 1ll * g[u][0] * g[v][2] % P);
        f[u][0] += f[v][1];
        g[u][0] = 1ll * g[u][0] * g[v][1] % P;
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        addedge(u, v);
        addedge(v, u);
    }
    dfs(1, 0);
    if (f[1][1] < f[1][2]) {
        printf("%d\n%d\n", f[1][1], g[1][1]);
    } else if (f[1][1] > f[1][2]) {
        printf("%d\n%d\n", f[1][2], g[1][2]);
    } else {
        printf("%d\n%d\n", f[1][1], (g[1][1] + g[1][2]) % P);
    }
    return 0;
}