这是一个经典的**树上的最小覆盖路径
问题**：
给定一棵 $ N $ 个节点的无根树（边权为1），对于每个查询 $ K $，要求选出 $ K $ 个点，使得 Claire 从某个入口出发，走完这 $ K $ 个点的**最短路径长度最小**。
她可以选择任意一个点作为起点，并且只需要访问这 $ K $ 个点（不要求返回）。
---
## ✅
问题转化
我们要找的是：在树中选择 $ K $ 个点，使得访问它们的最短路径长度最小。
等价于：**找出一个包含 $ K $ 个节点的连通子树，其“遍历距离”最小**。
而遍历一棵树的最小距离 = $ 2 \times
(\text{边数}
) - (\text{最长链长度}
) $
但注意：我们不需要回到起点 ⇒ 最优路径是沿着子树的一条路径走，不回头。
实际上，**访问一个点集的最短路径 = 该点集诱导子树的边数 × 2
- 直径**
更简单的方法是：
> 在树中，访问 $ K $ 个点的最短路径长度 = $ 2 \times
(K
- 1
) - \max_{\text{diameter of K
-node subtree}}
(\text{diam}
- 1
) $? 不直观。
---
## ✅ 正确思路：贪心构造最长可能路径
关键观察：
- Claire 可以从任意点开始
- 她要访问 $ K $ 个点，最优方式是选择一个**直径尽可能长的连通子图**，然后从一端走到另一端
- 实际上，最优策略是：**选一条路径（链）作为主干，然后尽量少走回头路**
但更好的方法来自经典结论：
> 访问 $ K $ 个点的最短路径长度 = $ 2 \times
(K
- 1
) - L + 1 $，其中 $ L $ 是所选 $ K $ 个点构成的子树中最长路径（即直径）
但这复杂。
---
## ✅ 经典结论（重要！）
> **最小行走距离 = $ 2 \times
(K
- 1
) - \max_{T' \subseteq T, |T'|=K} \text{diameter}
(T'
) $ 的最大值？不对**
反例：如果选的是一条链，则距离 = $ K
- 1 $
如果选的是星型，则距离 = $ 2
(K
-1
) $（必须来回）
所以我们应该**最大化所选 $ K $ 个点之间的连通性和路径长度**
### 🌟 正确结论：
> 要使行走距离最短，应选择一个**包含最多“连续路径”的子树**，即：**优先选择一条长链，再添加靠近它的点**
但实际上，最优解是：
> **最小路径长度 = $ 2 \times
(K
- 1
) - \max_{P}
(|P|
- 1
) $**，其中 $ P $ 是所选子树中的最长路径？
No.
---
## ✅ 真正正确的思路：**删边法 + 树的直径**
来自 ACM/ICPC 经典题：
> 在一棵树中，访问 $ K $ 个点的最短路径 = $ 2 \times
(K
- 1
) - \max_{S \subseteq V, |S|=K} \text{diameter}
(S
) + 1 $? 还是否
等等！
### ✅ 正确模型：
想象你构建了一个包含 $ K $ 个点的子树 $ T_K $。
遍历这个子树所需的最短路径是：**从某点出发，走完所有边至少一次？不，可以路过而不回溯**
但 Claire 不需要走所有边，只需访问这些点。所以最优路径是：**在这棵子树中找一条最长路径（直径），然后从一端走到另一端，途中会经过所有点吗？不一定**
但她可以走一条路径，覆盖尽可能多的点。
然而，为了最小化行走距离，我们应该让这 $ K $ 个点**尽可能集中在一个链上**。
---
## ✅ 最佳策略：**答案 = $ K
- \max_{\text{path
in tree}} \m
in(K, \text{number of nodes on path}
) $ ? No**
---
## ✅ 正解来源：CodeForces / ICPC 类似题 —— “Tree and $ K $ vertices”
### 🔥 关键洞察：
> **最小行走距离 = $ 2K
- 2
- \max_{u,v} \m
in(K, \text{dist}
(u,v
)) $**? 不对
---
## ✅ 查阅类似题目后得出：这是「选择 $ K $ 个点，使其诱导子树的边权和最小」的
问题
但我们是要最小化**行走路径**，不是子树大小。
### 🚀 正确模型：
- 一旦选定 $ K $ 个点，最优行走路径是从某个点出发，DFS 遍历整个连通部分，但可以最后停在叶子。
- 这样的路径长度 = $ 2 \times
(内部边数
) - (最长路径
)$
- 更准确地说：**任何树的遍历，最少行走距离 = $ 2 \times
(边数
) - \text{diameter}$**
因为你可以从直径一端走到另一端，中间分支都走
两次（去回），唯独直径只走一次。
设选中的 $ K $ 个点形成一棵子树 $ T_K $，有 $ E = K
- 1 $ 条边。
则遍历它所需距离 = $ 2
(K
- 1
) - D $，其中 $ D $ 是该子树的直径。
要最小化这个值 ⇒ 就要**最大化 $ D $**，即让这 $ K $ 个点尽可能分布在一条长链上。
所以：
> 最小距离 = $ 2
(K
- 1
) - \max D $
但 $ D \leq \m
in(K, \text{tree diameter}
) $
而且我们能构造出 $ D = \m
in(K, \text{longest path
in tree}
) $
但 not al
ways.
---
## ✅ 正确做法（Accepted 思路）：
> **答案 = $ 2K
- 2
- \ell $**，其中 $ \ell $ 是能在树中找到的、长度为 $ K $ 的连通子图中最长的路径长度（即最大可能直径）
但我们无法枚举所有子图。
---
## ✅ 实际正确解法（基于“重心扩展”或“直径中心”）
### 🌟 经典结论（来自 CF 和 ICPC）：
> 在树中，访问 $ K $ 个点的最短路径长度 = $ 2K
- 2
- \max_{v} \m
in(K, \text{longest path through } v
) $ ? No
---
## ✅ 换个角度：**答案 = $ K
- \max_{\text{cha
in}} \m
in(K, \text{length of cha
in}
) $**? No
---
## ✅ 观察样例
```
输入
:
1
4 2
3 2
1 2
4 2
2
4
```
树结构：
```
3
|
2
/ \
1 4
```
形状是：2 是中心，连接 1,3,4
- 查询 K=2：选哪两个点？
- 选相邻两点，如 2 和 1 ⇒ 路径长 = 1
- 输出 1 ✅
- 查询 K=4：必须 visit all
- 例如：1→2→3→4，距离 = 3？但输出是 4 ❌
Wait! Output is
:
```
1
4
```
So for K=4, answer is 4?
How?
Let’s simulate
:
To visit all 4 nodes start
ing from any po
int.
Best route
: start at 1 → 2 → 3 → 2 → 4, distance = 4
Yes! Because you have to go back to 2 after visit
ing 3, then go to 4.
You cannot avoid backtrack
ing.
Number of edges traversed = 4
In a tree with K=4 nodes, if the structure forces backtrack
ing, the m
inimum walk = 2*
(K
- 1
) - (diameter
- 1
)
Here
:
- K = 4
- Edges = 3
- But you must traverse some edge twice
Specifically
: any traversal that visits all nodes
in a tree must use each edge at least once; if it's not on the ma
in path, it may be used twice.
The m
inimum walk
ing distance to visit K nodes = $ 2 \times
(K
- 1
) - \text{length of the longest simple path among the selected K nodes} $
Because
:
- You can save one traversal for each edge on the f
inal path
(you don't backtrack
)
- All other branches are entered and left ⇒ cost 2 per edge
- The unique path from start to end is only walked once
So total = $ 2
(E
) - (L
- 1
) $ where $ E = K
- 1 $, $ L = \text{number of nodes on the path} $, so $ L
- 1 = \text{length
in edges} $
Let $ D $ = number of edges
in the longest path with
in the selected set ⇒ saves $ D $ steps
Then total distance = $ 2
(K
-1
) - D $
We want to m
inimize this ⇒ maximize $ D $
So
:
> Answer = $ 2
(K
- 1
) - \max D $
And $ \max D $ over all K
-node subtrees = the maximum possible diameter of any connected K
-node subtree
But how to compute it fast?
---
## ✅
Insight
: the optimal set is al
ways a union of a long path plus nearby nodes
But even better
: **the maximum possible diameter among any K
-node connected subtree is m
in(K
-1, global_diameter
)**
No. For example, if K=2, max diameter = 1
If K=3, we can get diameter 2 if there is a path of length 2
So yes, max possible D = m
in(K
-1, global_tree_diameter
)
Wait
: in our sample
:
- Global tree
: 1
-2
-3 or 1
-2
-4 or 3
-2
-4, diameter = 2
(e.g., 3
-2
-4 has length 2
)
- For K=4
: max possible diameter = 2
(s
ince no three
-edge path
)
- So answer = 2*
(4
-1
) - 2 = 6
- 2 = 4 ✅
- For K=2
: max possible diameter = 1 ⇒ answer = 2*1
- 1 = 1 ✅
Perfect!
So algorithm
:
1.
Find the **diameter of the tree**
(in terms of number of edges
)
- Use two
BFS/DFS
: pick any node,
find farthest, then from that
find farthest aga
in ⇒ distance is diameter
(edge count
)
2. Precompute for each K from 1 to N
:
- `ans[K] = 2*
(K
- 1
) - m
in(K
- 1, diam
)`
- because max achievable diameter
in K
-node subtree is `m
in(K
-1, diam
)`
- when K=1, ans=0
But wait
: can we al
ways achieve diameter = m
in(K
-1, diam
)?
Yes! Because we can take a segment of the diameter path of length `m
in(K, diam+1
)` nodes, which gives diameter `m
in(K
-1, diam
)`
And add
ing extra nodes won’t
increase the diameter beyond `diam`, but we can al
ways select a path of length `m
in(K
-1, diam
)`
So yes.
Therefore
:
> **Answer for query K = 2*
(K
- 1
) - m
in(K
- 1, diameter
)**
=
$$
\beg
in{cases}
2K
- 2
- (K
- 1
) = K
- 1 & \text{if } K
- 1 \leq \text{diam} \\
2K
- 2
- \text{diam} & \text{otherwise}
\end{cases}
$$
But s
ince `m
in(K
-1, diam
)` is just `K
-1` if `K
-1 <= diam`, else `diam`
So
:
```cpp
ans = 2*
(K
-1
) - m
in(K
-1, diam
);
```
Which simplifies to
:
- If K
-1 <= diam
: ans = 2*
(K
-1
) - (K
-1
) = K
-1
- Else
: ans = 2*
(K
-1
) - diam
But
in our case
:
- diam = 2
(edges
), e.g., 3
-2
-4
- K=2
: 2
-1=1 <= 2 ⇒ ans = 1 ✅
- K=4
: 4
-1=3 > 2 ⇒ ans = 2*3
- 2 = 6
- 2 = 4 ✅
Perfect.
---
## ✅ C++ 实现代码
```cpp
#
include <iostream>
#
include <vector>
#
include <queue>
#
include <algorithm>
#
include <cstr
ing>
us
ing namespace std;
typedef pair<
int,
int> pii;
//
BFS 返回 {farthest_node, distance}
pii
bfs(const vector<vector<
int>>& graph,
int start
) {
int n = graph.size
();
vector<
int> dist
(n,
-1
);
queue<
int> q;
q.push
(start
);
dist[start] = 0;
int u = start;
while
(!q.empty
()) {
u = q.front
(); q.pop
();
for
(int v
: graph[v]
) {
if
(dist[v] ==
-1
) {
dist[v] = dist[u] + 1;
q.push
(v
);
}
}
}
int maxDist = 0;
int farthest = start;
for
(int i = 1; i < n; ++i
) {
if
(dist[i] > maxDist
) {
maxDist = dist[i];
farthest = i;
}
}
return {farthest, maxDist};
}
int ma
in() {
ios
::sync_with_stdio
(false
);
c
in.tie
(0
);
int T;
c
in >> T;
while
(T
--) {
int N, M;
c
in >> N >> M;
vector<vector<
int>> graph
(N + 1
);
for
(int i = 0; i < N
- 1; ++i
) {
int u, v;
c
in >> u >> v;
graph[u].push_back
(v
);
graph[v].push_back
(u
);
}
// Step 1
: find diameter us
ing two
BFS
int start = 1;
pii p1 =
bfs(graph, start
);
pii p2 =
bfs(graph, p1.first
);
int diameter = p2.second; //
in terms of number of edges
// Process queries
while
(M
--) {
int K;
c
in >> K;
if
(K == 1
) {
cout << 0 << '\n';
} else {
int max_achievable_diameter = m
in(K
- 1, diameter
);
int ans = 2 *
(K
- 1
) - max_achievable_diameter;
cout << ans << '\n';
}
}
}
return 0;
}
```
⚠️ Fix bug
in BFS loop
:
```cpp
for
(int v
: graph[u]
) { // was 'graph[v]'
```
---
## ✅ Fixed
BFS function
```cpp
pii
bfs(const vector<vector<
int>>& graph,
int start
) {
int n = graph.size
();
vector<
int> dist
(n,
-1
);
queue<
int> q;
q.push
(start
);
dist[start] = 0;
int u = start;
while
(!q.empty
()) {
u = q.front
(); q.pop
();
for
(int neighbor
: graph[u]
) { // fixed
: graph[u], not graph[v]
if
(dist[neighbor] ==
-1
) {
dist[neighbor] = dist[u] + 1;
q.push
(neighbor
);
}
}
}
int maxDist = 0;
int farthest = start;
for
(int i = 1; i < n; ++i
) {
if
(dist[i] > maxDist
) {
maxDist = dist[i];
farthest = i;
}
}
return {farthest, maxDist};
}
```
---
## ✅ Summary
- Diameter of tree found by two
BFS
- For each query K
:
- If K == 1
: 0
- Else
: `ans = 2*
(K
-1
) - m
in(K
-1, diameter
)`
- This works because the best
way to m
inimize walk
ing is to choose a set of K nodes with the largest possible
internal diameter, sav
ing backtrack
ing on that path.
---
本文介绍了一个关于寻找两个人到达同一地点最短总时间的问题，并通过使用广度优先搜索（BFS）算法解决这一问题。文章提供了完整的C++代码实现，展示了如何在一张地图上找到从两个不同起点到特定目标点的最短路径。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
