UVa 1407 Caves

题目描述

$\text{Menggol}$ 部落居住在洞穴中，这些洞穴通过路径连接形成一个树形结构。树中有一个主洞穴（编号为 $0$）作为入口。机器人从主洞穴出发，探索洞穴时不需要返回主洞穴，但总行走距离不能超过 $x$ 米。

输入：多组测试用例。每组第一行是洞穴数 $n$（$0\le n\le 500$），接着 $n-1$ 行每行给出 $i,j,d$，表示 $i$ 的父洞穴是 $j$，距离为 $d$。然后是一个整数 $q$（$1\le q\le 1000$）表示查询数，随后 $q$ 行每行一个整数 $x$（$0\le x\le 5000000$）表示机器人最大行走距离。

输出：对每个查询输出机器人能访问的最大洞穴数。

---

题目分析

本题是一个典型的树形动态规划问题。我们需要在树上计算从根节点出发，在总距离限制下最多能访问的节点数。

关键点：

• 树的结构：以 $0$ 号节点为根的树
• 机器人不需要返回起点，这意味着在某个子树中探索后可以不回到父节点
• 需要处理多个查询，因此需要预处理出所有可能的访问节点数对应的最小距离

---

解题思路

状态设计

我们定义两个动态规划数组：

• $dp[u][k]$：在以节点 $u$ 为根的子树中，访问恰好 $k$ 个节点，并且最终回到节点 $u$ 的最小总距离
• $f[u][k]$：在以节点 $u$ 为根的子树中，访问恰好 $k$ 个节点，并且最终不回到节点 $u$ 的最小总距离

状态转移

对于每个节点 $u$ 和其子节点 $v$（边权为 $w$），我们进行背包式的合并：

1. 回到 $u$ 的情况：

   • 如果从 $v$ 的子树回到 $v$，那么需要额外走 $2\times w$ 的距离（去和回）
   • 转移：$dp[u][i+j]=\min (dp[u][i+j],dp[u][i]+dp[v][j]+2\times w)$

2. 不回到 $u$ 的情况，有两种可能：

   • 在之前的子树中不返回，在当前子树 $v$ 中返回：$f[u][i]+dp[v][j]+2\times w$
   • 在之前的子树中返回，在当前子树 $v$ 中不返回：$dp[u][i]+f[v][j]+w$
   • 转移：$f[u][i+j]=\min (f[u][i+j],\min (f[u][i]+dp[v][j]+2\times w,dp[u][i]+f[v][j]+w))$

查询处理

对于每个查询 $x$，我们在根节点 $0$ 处寻找最大的 $k$，使得 $\min (dp[0][k],f[0][k])\le x$。

算法复杂度

• 时间复杂度：$O(n^3)$，在 $n\le 500$ 的情况下可以通过
• 空间复杂度：$O(n^2)$

---

代码实现

// Caves
// UVa ID: 1407
// Verdict: Accepted
// Submission Date: 2025-11-25
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

const int INF = 0x3f3f3f3f;
const int MAXN = 505;

vector<pair<int, int>> graph[MAXN];
int dp[MAXN][MAXN], f[MAXN][MAXN];
int size[MAXN];
int n, q;

void dfs(int u) {
    size[u] = 1;
    dp[u][1] = f[u][1] = 0;
    for (auto& edge : graph[u]) {
        int v = edge.first, w = edge.second;
        dfs(v);
        for (int i = size[u]; i >= 1; --i) {
            for (int j = 1; j <= size[v]; ++j) {
                dp[u][i + j] = min(dp[u][i + j], dp[u][i] + dp[v][j] + 2 * w);
                f[u][i + j] = min(f[u][i + j], min(f[u][i] + dp[v][j] + 2 * w, dp[u][i] + f[v][j] + w));
            }
        }
        size[u] += size[v];
    }
}

int main() {
    int caseNum = 1;
    while (cin >> n, n) {
        for (int i = 0; i < n; ++i) graph[i].clear();
        for (int i = 0; i < n - 1; ++i) {
            int a, b, d;
            cin >> a >> b >> d;
            graph[b].push_back({a, d});
        }
        memset(dp, 0x3f, sizeof dp);
        memset(f, 0x3f, sizeof f);
        dfs(0);
        cin >> q;
        cout << "Case " << caseNum++ << ":" << endl;
        while (q--) {
            int x;
            cin >> x;
            int ans = 1;
            for (int k = n; k >= 1; --k) {
                if (min(dp[0][k], f[0][k]) <= x) {
                    ans = k;
                    break;
                }
            }
            cout << ans << endl;
        }
    }
    return 0;
}

---

总结

本题通过巧妙的动态规划状态设计，分别处理了「返回根节点」和「不返回根节点」两种情况，从而在树形结构上解决了带距离限制的最大访问节点数问题。这种「背包合并」的思想在树形动态规划中非常常见，是解决此类问题的经典方法。