[SMOJ1785]修复道路

题目描述

有一颗树，$N$ 个结点，那么至少要删除多少条边之后，使得存在一颗子树，该子树恰好有 $P$ 个结点？

输入格式 1785.in

第一行，两个整数，$N$ 和 $P$。
接下来有 $N-1$ 行，每行两个整数：$a$ $b$，表示结点 $a$ 是结点 $b$ 的父亲结点。

输出格式 1785.out

最少需要删除的边的数量。

输入样例 1785.in

11 6
1 2
1 3
1 4
1 5
2 6
2 7
2 8
4 9
4 10
4 11

输出样例 1785.out

2

样例解释

删除结点1与结点4之间的边，再删除结点1至5之间的边，就可以得到一颗恰好含有6个结点的子树。

---

题目描述比较简明，不再重复。

先把样例画出来看一看：

要删去一些边，使得留下一个含 6 个结点的子树。那么就可以删去 1 跟 4 之间的边和 1 跟 5 之间的边，剩下的 1、2、3、6、7、8 恰好是 6 个结点。

当然，还有其他的一些方案。

不妨记 $f[root][x]$ 表示在以 $root$ 为根的子树中删一些边，使得该子树中剩下 $x$ 个结点，所要删的最小边数。

这样一来，答案就是 $min\left\{f[i][p]\right\}$，枚举一下作为子树根结点的 $i$ 就可以了。

好了，状态是描述出来了，所要求的解我们也知道了。还剩下两个比较关键的东西：边界条件和状态转移。

先来看边界条件，相对来说比较容易。

如果要使以 $root$ 为根的子树只剩一个结点，那么必然只能留下 $root$，于是要删去的边数就是 $root$ 的儿子个数 +1，其实也就是与 $root$ 相连的边数。

对于剩下更多结点的情况，我们暂时无从得知。那么因为是要求最小值，不妨初始化为 $\infty$ 好了。

接下来就是重头戏——状态转移。

对于某棵子树的根结点 $root$，若要使以它为根的子树剩下 $x$ 个结点，那么肯定要在一些儿子里面删边。我们就一个儿子一个儿子来考虑。

还是拿样例比较好讲，请参考上面的图：以 2 作为根为例。

对于第一个儿子 6，它只需删去 1 条边就可以得到一棵含一个结点的子树，因此对于 2 来看，如果要得到一棵含两个结点的子树，这两个结点一个必须是根结点 2 自己，另一个就可以是第一个儿子 6。也就是要在第一棵子树中取一个点，剩下 2 - 1 = 1 个点从自己整棵子树其他儿子来考虑。

也就是此时
f[2][2] = f[6][1] + f[2][1] = 1 + 4 =5，但是，明明只需要删去 3 条边就可以了。
我们发现，对于 2 -> 6 这条边，f[6][1] 和 f[2][1] 都把它算在内了。可是，既然第一棵子树对自己是有贡献的，那么跟这棵子树联系的边怎么可能被删去呢？

于是再减去 2，就对了。

其他的儿子同理。归纳一下，如果我们将已经考虑了前面所有儿子的 DP 数组定为 $f$，而 $g$ 是要包含考虑前面所有儿子和当前儿子的 DP 数组，那么就有

$$g[root][i]=min\left\{f[root][i],g[son][j]+f[root][i-j]-2\right\}$$

然后每次算完还要滚动一下，把 $g$ 数组里的值复制到 $f$ 里面。

慢着，其实真的要这么麻烦吗？难道就不能用一个数组解决？

其实也是可以的。

我们发现，随着 $i$ 的减小，$i - j$ 也会随之减小。即，影响 $g[root][i]$ 的都是它前面的值。

如果从小到大枚举 $i$，那么更新也是从前到后，取值也是取在自己前面的，就有可能会得到包含考虑了当前儿子的值，这样就会造成混乱了。

但其实我们可以在 for 循环的时候从大到小枚举 $i$，这样一来，更新是从后往前，取值时只取在自己前面的，就可以保证所有取到的值都是没有考虑当前儿子的，这样只用一个数组做就可以了。

这就是为什么 lgj 说，for循环的顺序非常重要。

有没有感觉很熟悉？这道题目看上去就是删一些边保留一些，细细品味一下，实质上是在树上做 01 背包。而最后的那个优化正是空间上一维的 01 背包。

参考代码：

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>

using namespace std;

const int maxn = 200;

int n, p;
vector <int> g[maxn];

bool vis[maxn];
int dp[maxn][maxn];

void dfs(int root) {
    vis[root] = true;
    dp[root][1] = g[root].size();
    for (int i = 2; i <= p; i++) dp[root][i] = 0x3f3f3f3f;
    for (int i = 0; i < g[root].size(); i++)
        if (!vis[g[root][i]]) {
            dfs(g[root][i]);
            for (int j = p; j > 1; j--)
                for (int k = 1; k < j; k++)
                    dp[root][j] = min(dp[root][j], dp[g[root][i]][k] + dp[root][j - k] - 2);
        }
}

int main(void) {
    freopen("1785.in", "r", stdin);
    freopen("1785.out", "w", stdout);

    scanf("%d%d", &n, &p);
    for (int i = 1; i < n; i++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        g[a].push_back(b);
        g[b].push_back(a);
    }

    memset(vis, false, sizeof vis);
    dfs(1);

    int ans = 0x7fffffff;
    for (int i = 1; i <= n; i++) ans = min(ans, dp[i][p]);
    printf("%d\n", ans);
    return 0;
}