NC13950 Alliances(DFS序 + LCA)

题目链接

题意：
$一个国家有n个城市，形成一棵树，有n-1条边$
$国家中有k个帮派，分别占领一些城市$
$每个帮派占领c_i个城市，以及这c_i个城市路径上的所有点$
$帮派可以联盟，联盟会将几个帮派的所有占领城市和路径上的城市占领$
$q次询问，首都如果建在v城市$
$求首都离给定t_i个帮派联盟中最近占领城市的距离$
题解：
$由于这是一棵树，路径只有一条，那么就假设根为1$
$那么就可以用LCA找到这些帮派占领的最高的父亲节点$
$求出每个帮派的LCA后，联盟的时候，找这几个帮派的LCA$
$如果发现首都不在这个LCA的子树中，那肯定最短距离就是到这个LCA的距离$
$树上两点距离可以用两点的深度和减去2倍两点LCA的深度求解$

$然后就要考虑如果首都建在这个子树里$
$子树里可能刚好在联盟占领的城市里，或者不在$
$由于每次询问给出的联盟帮派个数不是很多$
$所以直接暴力枚举这些联盟帮派，找最近点$
$这时候就要用到dfs序$
$利用二分在每个帮派占领的城市中，找到距离首都城市最近的两个城市$
$也就是第一个大于等于他，和第一个小于他的城市$
$(因为找的是大于等于，如果有等于的情况就说明首都就是被占领点，结果是0)$
$由于首都是在联盟的LCA的子树中，所以找到的这两个被占领的城市$
$到他们父亲结点的路径一定全部都是被占领的$
$所以想要找最近的，就应该找到首都和他们的LCA$

$这个图中，假设黑色是被占领点，如果1和4被占领$
$1就是这个联盟占领的最高点，将在6建首都，6在最高点的子树中$
$标注的123456代表的就是dfs序，6相邻最近被占领的点是4$
$但是4到6的距离明显没有1到6近，所以要进行对4和6求LCA$
$然后再计算这个LCA到6的距离才是最近的$

$找第一个大于等于首都dfs序的点也是类似道理$
$这个图没有表示全部情况，只举例说了一下找第一个小于的$
$然后在这两个点都能取到的情况下取最小结果，就是最终答案$

AC代码

/*
    Author : zzugzx
    Lang : C++
    Blog : blog.csdn.net/qq_43756519
*/
#include
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define endl '\n'
#define SZ(x) (int)x.size()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mod = 1e9+7;
//const int mod = 998244353;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int maxn = 1e6+10;
const ll inf = 0x3f3f3f3f;
const int dir[][2]={{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};

int n,depth[maxn], f[maxn][50];
int from[maxn], to[maxn << 1], nxt[maxn << 1], cnt, Log[maxn];
int L[maxn], R[maxn], id, pos[maxn], top[maxn];
void addEdge (int u, int v) {
    to[++cnt] = v, nxt[cnt] = from[u], from[u] = cnt;
}
void dfs (int u, int fa) {
    depth[u] = depth[fa] + 1;
    L[u] = ++id;
    pos[id] = u;
    for (register int i = 1; i <= Log[n]; ++i) {
        if ((1 << i) > depth[u]) break;
        f[u][i] =  f[f[u][i - 1]][i - 1];
    }
    for (register int i = from[u]; i; i = nxt[i]) {
        ll v = to[i];
        if (v == fa) continue;
        f[v][0] = u;
        dfs (v, u);
    }
    R[u] = id;
}
inline int LCA (int x, int y) {
    if (depth[x] < depth[y]) swap(x, y);
    for(register int i = Log[n] ; i >= 0 ; --i)
		if(depth[x] - (1 << i) >= depth[y]) x = f[x][i];
    if (x == y) return x;
    for (register int i = Log[n]; i >= 0; --i)
        if (f[x][i] != f[y][i])
            x = f[x][i], y = f[y][i];
    return f[x][0];
}
void init(){
	Log[0] = -1;
    for (register int i = 1, u, v; i < n; ++i) {
        cin >> u >> v;
        addEdge (u, v); addEdge(v, u);
        Log[i] = Log[i >> 1] + 1;
    }
    Log[n] = Log[n >> 1] + 1;
    dfs(1,0);
}
int dis(int p , int q){return depth[p] + depth[q] - 2 * depth[LCA(p , q)];}
vector<int> g[maxn];
int a[maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
//  freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
    cin >> n;
    init();
    int q;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        int k;
        cin >> k;
        for(int j = 1; j <= k; j++) {
            int x;
            cin >> x;
            g[i].pb(L[x]);
            if (j == 1) top[i] = x;
            else top[i] = LCA(top[i], x);
        }
        sort(all(g[i]));
    }
    cin >> q;
    while (q--) {
        int v, t;
        cin >> v >> t;
        int rt;
        for (int i = 1; i <= t; i++){
            cin >> a[i];
            if (i == 1) rt = top[a[i]];
            else rt = LCA(rt, top[a[i]]);
        }
        if (L[v] < L[rt] || L[v] > R[rt]) {
            cout << dis(v, rt) << endl;
            continue;
        }
        int ans = inf;
        for (int i = 1; i <= t; i++){
            auto p = lower_bound(all(g[a[i]]), L[v]);
            if (p != g[a[i]].end())
                ans = min(ans, dis(v, LCA(v, pos[*p])));
            if (p !=g[a[i]].begin())
                ans = min(ans, dis(v, LCA(v, pos[*prev(p)])));
        }
        cout << ans << endl;
    }
    return 0;
}