Innumerable Ancestors 尺取 dfs序 lca

最新推荐文章于 2023-09-20 19:25:00 发布

5pace

最新推荐文章于 2023-09-20 19:25:00 发布

阅读量122

点赞数 1

文章标签：图论

本文链接：https://blog.csdn.net/m0_51448653/article/details/120970193

版权

在这里插入图片描述

给一棵树，m次查询，每次查询给两个集合，从这两个集合中分别选一个结点，使得这两个结点的lca的深度最大
考虑dfs序为3， 4， 5的三个结点，3和4的lca深度一定大于等于3和5的lca深度
所以可以将查询集合按dfs序进行排序，然后双指针，使每一对dfs序接近的结点都做一次lca，取最深的即可。尺取的思想。

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

using namespace std;

const int N = 1e5 + 10;

int n, m;
vector<int> G[N];
int dep[N], id[N], fa[N], tot;
int up[N][21];
int s1[N], s2[N];

void dfs(int from, int x)
{
    id[x] = tot ++ ;
    fa[x] = from;
    dep[x] = dep[from] + 1;
    for (int i = 0; i < (int)G[x].size(); i ++ )
        if (from != G[x][i])
            dfs(x, G[x][i]);
    return ;
}

void init()
{
    for (int i = 1; i <= n; i ++ )	// 先跳0层
        up[i][0] = fa[i];
    for (int k = 1; k <= 20; k ++ )		// [1, 20]
        for (int i = 1; i <= n; i ++ )
            up[i][k] = up[up[i][k - 1]][k - 1];
    return ;
}

bool cmp(int u, int v)
{
    return id[u] < id[v];
}

int lca(int a, int b)
{
    if (dep[a] < dep[b]) swap(a, b);
    for (int k = 20; k >= 0; k -- )		// [20, 1]
        if (dep[up[a][k]] >= dep[b])
            a = up[a][k];
    
    if (a == b) return a;
    
    for (int k = 20; k >= 0; k -- )		// [20, 1]
        if (up[a][k] != up[b][k])
        {
            a = up[a][k];
            b = up[b][k];
        }
    
    return up[a][0];
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    
    while (cin >> n >> m)
    {
        for (int i = 1; i <= n; i ++ ) G[i].clear();	// 清空
        tot = 0;	// 清空
        
        for (int i = 0; i < n - 1; i ++ )
        {
            int u, v;
            cin >> u >> v;
            G[u].push_back(v), G[v].push_back(u);
        }
        
        dfs(0, 1);	// dfs序，深度，父节点
        init();	 // 发展up数组
        
        while (m -- )
        {
            int k1, k2;
            cin >> k1;
            for (int i = 0; i < k1; i ++ ) cin >> s1[i];
            cin >> k2;
            for (int i = 0; i < k2; i ++ ) cin >> s2[i];
            
            sort(s1, s1 + k1, cmp);	// 按dfs序排序
            sort(s2, s2 + k2, cmp);
            
            int i = 0, j = 0, ans = 0;
            while (i < k1 && j < k2)
            {
                ans = max(ans, dep[lca(s1[i], s2[j])]);	// 注意的深度dep
                if (id[s1[i]] > id[s2[j]]) j ++ ;
                else i ++ ;
                // 如果第一个集合的点的dfs序大于第二个中的dfs序，则选第二个中的dfs序更大
            }
            
            cout << ans << endl;
        }
    }
    
    return 0;
}