#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int n, m;
int r1, r2;
vector<int> ke[maxn + 5];
vector<int> path;
int trace_par[maxn + 5];
int dp[maxn + 5];
void dfs_trace(int u, int p) {
    trace_par[u] = p;
    for (int v : ke[u]) {
        if (v == p) continue;
        dfs_trace(v, u);
    }
}
void findpath() {
    path.clear();
    dfs_trace(r1, 0);
    int u = r2;
    while (u != 0) {
        path.push_back(u);
        if (u == r1) break;
        u = trace_par[u];
    }
    reverse(path.begin(), path.end());
}
void dfs_compute(int u, int p, int blocked1, int blocked2) {
    vector<int> children;
    for (int v : ke[u]) {
        if (v == p) continue;
        if (u == blocked1 && v == blocked2) continue;
        if (u == blocked2 && v == blocked1) continue;
        dfs_compute(v, u, blocked1, blocked2);
        children.push_back(v);
    }
    sort(children.begin(), children.end(), [](int a, int b) {
        return dp[a] > dp[b];
    });
    for (int i = 0; i < children.size(); i++) {
        dp[u] = max(dp[u], dp[children[i]] + i + 1);
    }
}
int calc_split(int mid) {
    if (mid < 0 || mid + 1 >= path.size()) return INT_MAX;
    fill(dp, dp + n + 1, 0);
    int blocked1 = path[mid], blocked2 = path[mid + 1];
    dfs_compute(r1, 0, blocked1, blocked2);
    dfs_compute(r2, 0, blocked1, blocked2);
    return max(dp[r1], dp[r2]);
}
void solve() {
    cin >> n >> r1 >> r2;
    for (int i = 1; i <= n; i++) ke[i].clear();
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        ke[u].push_back(v);
        ke[v].push_back(u);
    }
    findpath();
    
    int ans = INT_MAX;
    for (int i = 0; i + 1 < path.size(); i++) {
        ans = min(ans, calc_split(i));
    }
    cout << ans;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
    return 0;
}
| # | Verdict | Execution time | Memory | Grader output | 
|---|
| Fetching results... | 
| # | Verdict | Execution time | Memory | Grader output | 
|---|
| Fetching results... |