acwing算法提高之图论--最近公共祖先

已于 2024-04-19 23:20:04 修改
阅读量599 收藏 3
点赞数 2
分类专栏： Acwing C++学习 文章标签： 算法 图论
于 2024-04-14 23:12:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMWM_/article/details/137749232
版权
C++学习 同时被 2 个专栏收录
207 篇文章 16 订阅
订阅专栏
Acwing
123 篇文章 1 订阅
订阅专栏
本文介绍了在有向图中求解最近公共祖先的不同方法，包括向上标记法、倍增法和Tarjan法，以及如何用C++实现解决具体问题如祖孙询问、距离计算和最小生成树。
摘要由CSDN通过智能技术生成

目录

1 介绍

本博客用来记录"对于有根图中，求最近公共祖先"的题目。

求解方法：

  1. 向上标记法。每次求两个结点的最近公共祖先的时间复杂度是O(N)。由于时间复杂度较高，通常不用。
  2. 倍增法。
  3. Tarjan法。

1.1 向上标记法

字面意思理解即可，存储每个结点的父结点。从结点a出发，往上走，一直走到根结点，标记走过的结点；然后从结点b出发，往上走，一直走到根节点，第一次遇到的标记过的结点就是这两个结点的最近公共祖先。

1.2 倍增法

倍增法重要思路：预处理出两个数组fa[i][j]和depth[i]。其中fa[i][j]表示从i开始，向上走2^j步所能走到的结点。0<=j<=logn。depth[i]表示深度，为到根结点的距离再加上1。

哨兵：如果从i开始跳2^j步会跳过根结点，那么fa[i][j] = 0，depth[0] = 0。

倍增法重要步骤：

  1. 先将两个点跳到同一层。
  2. 让两个点同时往上跳，一直跳到它们的最近公共祖先的下一层。

倍增法的时间复杂度分析：预处理的时间复杂度为O(NlogN)，查询的时间复杂度为O(logN)。

1.3 Tarjan法

对结点进行分类，离线做法。

2 训练

题目1：1172祖孙询问

C++代码如下，

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <unordered_map>

using namespace std;

const int N = 40010;
int n, m;
int depth[N], fa[N][16];
int ancestor;
unordered_map<int, vector<int>> g;

void bfs(int root) {
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0;
    depth[root] = 1; 
    
    queue<int> q;
    q.push(root);
    
    while (!q.empty()) {
        int a = q.front();
        q.pop();
        
        for (auto b : g[a]) {
            if (depth[b] > depth[a] + 1) {
                depth[b] = depth[a] + 1;
                q.push(b);
                fa[b][0] = a;
                for (int k = 1; k <= 15; ++k) {
                    fa[b][k] = fa[fa[b][k-1]][k-1];
                }
            }
        }
    }
    return;
}

int lca(int a, int b) {
    //倍增法
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 15; k >= 0; --k) {
        if (depth[fa[a][k]] >= depth[b]) {
            a = fa[a][k];
        }
    }
    
    if (a == b) return a;
    
    for (int k = 15; k >= 0; --k) {
        if (fa[a][k] != fa[b][k]) {
            a = fa[a][k];
            b = fa[b][k];
        }
    }
    return fa[a][0];
}

int main() {
    cin >> n;
    int a, b;
    for (int i = 0; i < n; ++i) {
        cin >> a >> b;
        if (b == -1) {
            ancestor = a;
        } else {
            g[a].emplace_back(b);
            g[b].emplace_back(a);        
        }
    }
    
    
    cin >> m;
    vector<pair<int,int>> queries;
    for (int i = 0; i < m; ++i) {
        cin >> a >> b;
        queries.emplace_back(a,b);
    }
    
    //从根结点开始遍历
    bfs(ancestor);
    
    for (auto [a, b] : queries) {
        int x = lca(a, b);
        if (a == x) {
            puts("1");
        } else if (b == x) {
            puts("2");
        } else {
            puts("0");
        }
    }
    
    return 0;
}

题目2：1171距离

C++代码如下，

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

using namespace std;

typedef pair<int, int> PII;

const int N = 10010, M = N * 2;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
int p[N];
int res[M];
int st[N];
vector<PII> query[N]; //first存b，second存i

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u, int fa) {
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == fa) continue;
        dist[j] = dist[u] + w[i];
        dfs(j, u);
    }
}

int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

void tarjan(int u) {
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (!st[j]) {
            tarjan(j);
            p[j] = u;
        }
    }
    
    for (auto item : query[u]) {
        int y = item.first, id = item.second;
        if (st[y] == 2) {
            int anc = find(y);
            res[id] = dist[u] + dist[y] - dist[anc] * 2;
        }
    }
    st[u] = 2;
}

int main() {
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    
    for (int i = 0; i < m; ++i) {
        int a, b;
        cin >> a >> b;
        if (a != b) {
            query[a].push_back({b,i});
            query[b].push_back({a,i});
        }
    }
    
    for (int i = 1; i <= n; ++i) p[i] = i;
    
    dfs(1, -1);
    tarjan(1);
    
    for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
    
    return 0;
}

题目3：356次小生成树

C++代码如下，

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>

using namespace std;

typedef long long LL;

const int N = 100010, M = 300010, INF = 0x3f3f3f3f;

int n, m;
struct Edge {
    int a, b, w;
    bool used;
    bool operator< (const Edge& t) const {
        return w < t.w;
    }
}edge[M];

int p[N];
int h[N], e[M], w[M], ne[M], idx;
int depth[N], fa[N][17], d1[N][17], d2[N][17];
int q[N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

LL kruskal() {
    for (int i = 1; i <= n; ++i) p[i] = i;
    sort(edge, edge + m);
    LL res = 0;
    for (int i = 0; i < m; ++i) {
        int a = find(edge[i].a), b = find(edge[i].b), w = edge[i].w;
        if (a != b) {
            p[a] = b;
            res += w;
            edge[i].used = true;
        }
    }
    return res;
}

void build() {
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; ++i) {
        if (edge[i].used) {
            int a = edge[i].a, b = edge[i].b, w = edge[i].w;
            add(a, b, w), add(b, a, w);
        }
    }
}

void bfs() {
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0, depth[1] = 1;
    q[0] = 1;
    int hh = 0, tt = 0;
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (depth[j] > depth[t] + 1) {
                depth[j] = depth[t] + 1;
                q[++tt] = j;
                fa[j][0] = t;
                d1[j][0] = w[i], d2[j][0] = -INF;
                for (int k = 1; k <= 16; ++k) {
                    int anc = fa[j][k-1];
                    fa[j][k] = fa[anc][k-1];
                    int distance[4] = {d1[j][k-1], d2[j][k-1], d1[anc][k-1], d2[anc][k-1]};
                    d1[j][k] = d2[j][k] = -INF;
                    for (int u = 0; u < 4; ++u) {
                        int d = distance[u];
                        if (d > d1[j][k]) d2[j][k] = d1[j][k], d1[j][k] = d;
                        else if (d != d1[j][k] && d > d2[j][k]) d2[j][k] = d; 
                    }
                }
            }
        }
    }
} 

int lca(int a, int b, int w) {
    static int distance[N * 2];
    int cnt = 0;
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 16; k >= 0; --k) {
        if (depth[fa[a][k]] >= depth[b]) {
            distance[cnt++] = d1[a][k];
            distance[cnt++] = d2[a][k];
            a = fa[a][k];
        }
    }
    if (a != b) {
        for (int k = 16; k >= 0; --k) {
            if (fa[a][k] != fa[b][k]) {
                distance[cnt++] = d1[a][k];
                distance[cnt++] = d2[a][k];
                distance[cnt++] = d1[b][k];
                distance[cnt++] = d2[b][k];
                a = fa[a][k], b = fa[b][k];
            }
        }
        distance[cnt++] = d1[a][0];
        distance[cnt++] = d1[b][0];
    }
    
    int dist1 = -INF, dist2 = -INF;
    for (int i = 0; i < cnt; ++i) {
        int d = distance[i];
        if (d > dist1) dist2 = dist1, dist1 = d;
        else if(d != dist1 && d > dist2) dist2 = d;
    }
    
    if (w > dist1) return w - dist1;
    if (w > dist2) return w - dist2;
    return INF;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        edge[i] = {a, b, c};
    }
    
    LL sum = kruskal();
    build();
    bfs();
    
    LL res = 1e18;
    for (int i = 0; i < m; ++i) {
        if (!edge[i].used) {
            int a = edge[i].a, b = edge[i].b, w = edge[i].w;
            res = min(res, sum + lca(a, b, w));
        }
    }
    
    printf("%lld\n", res);
    
    return 0;
}

题目4：352暗之连锁

C++代码如下，

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = N * 2;

int n, m;
int h[N], e[M], ne[M], idx;
int depth[N], fa[N][17];
int d[N];
int q[N];
int ans;

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void bfs() {
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0, depth[1] = 1;
    int hh = 0, tt = 0;
    q[0] = 1;
    
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (depth[j] > depth[t] + 1) {
                depth[j] = depth[t] + 1;
                q[++tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 16; ++k) {
                    fa[j][k] = fa[fa[j][k-1]][k-1];
                }
            }
        }
    } 
}

int lca(int a, int b) {
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 16; k >= 0; --k) {
        if (depth[fa[a][k]] >= depth[b]) {
            a = fa[a][k];
        }
    }
    if (a == b) return a;
    for (int k = 16; k >= 0; --k) {
        if (fa[a][k] != fa[b][k]) {
            a = fa[a][k];
            b = fa[b][k];
        }
    }
    return fa[a][0];
}

int dfs(int u, int father) {
    int res = d[u];
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j != father) {
            int s = dfs(j, u);
            if (s == 0) ans += m;
            else if (s == 1) ans++;
            res += s;
        }
    }
    return res;
}

int main() {
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; ++i) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }
    
    bfs();
    
    for (int i = 0; i < m; ++i) {
        int a, b;
        scanf("%d%d", &a, &b);
        int p = lca(a, b);
        d[a]++, d[b]++, d[p] -= 2;
    }
    dfs(1, -1);
    printf("%d\n", ans);
    
    return 0;
}
YMWM_
关注
专栏目录
acwing和leetcode-Algorithm-All-Know:从零开始刷算法题
07-07
《算法大全：从零开始刷ACWing与LeetCode》 在编程的世界里，算法是解决问题的核心工具，它像一把钥匙，能打开高效解决问题的大门。ACWing和LeetCode作为两大知名的在线算法练习平台，提供了丰富的算法题目，旨在...
算法刷题提高阶段-图论7
12-24
"算法刷题提高阶段-图论7"的主题很可能聚焦于图论中的一个关键算法——SPFA（Shortest Path Faster Algorithm）寻找负权环。 SPFA算法是一种用于解决单源最短路径问题的算法，尤其适用于存在负权重边的情况。与...
AcWing算法提高课 Level-3 第三章 图论
m0_51448653的博客
10-14 303
单源最短路的建图方式 1129. 热浪 思路 ：单源最短路算法中除了bellmanford一般不用以外，普D为O(n2)O(n^2)O(n2)，优D为O(m∗logn)O(m*logn)O(m∗logn)，spfa平均是O(m)O(m)O(m) 语法 ：链式前向星时注意如果无向图边数开数组要*2 #include <iostream> #include <cstring> #include <queue> using namespace std; const i
AcWing算法提高课----图论 笔记 （LCA最近公共祖先 向上标记法 + 倍增法 + Tarjan离线求LCA）
qq_45830025的博客
08-18 501
最近公共祖先LCA问题1. 向上标记法 O(n)2. 倍增法 O(mlogn)方法3：Tarjan算法——离线求LCA O(n+m)例题1：AcWing1172.祖孙查询（倍增法）例题2：AcWing1171.距离（Tarjan离线LCA算法） LCA问题 解决方法： 1. 向上标记法 O(n) 从x向上走到根节点， 并标记路径上经过的点 从y向上走到根节点， 当遇到第一个被标记的点就找到了LCA(x, y) 2. 倍增法 O(mlogn) 预处理fa[i,j]表示从i开始，向上走2^j
【算法题归纳合集】图论-最近公共祖先
一只快乐的小蒟蒻~
02-20 445
一、AcWing 1172. 祖孙询问 【题目描述】 给定一棵包含nnn个节点的有根无向树，节点编号互不相同，但不一定是1∼n1\sim n1∼n。 有mmm个询问，每个询问给出了一对节点的编号xxx和yyy，询问xxx与yyy的祖孙关系。 【输入格式】 输入第一行包括一个整数nnn表示节点个数； 接下来nnn行每行一对整数aaa和bbb，表示aaa和bbb之间有一条无向边。如果bbb是−1-1−1，那么aaa就是树的根； 第n+2n+2n+2行是一个整数mmm表示询问个数； 接下来mmm行，每行两个不同的
AcWing-算法提高课【合集】
violet的博客
08-29 1万+
先打基础再提高
题355.lca问题-acwing-Q1636--最低公共祖先
Adongua的博客
07-11 99
lca
acwing算法提高课第三章图论
最新发布
2301_79203206的博客
05-18 2073
包括单源最短路的建图方式、单源最短路的综合应用、单源最短路的扩展应用、Floyd算法、最小生成树、最小生成树的扩展应用、负环、差分。AcWing 920. 最优乘车 可以。AcWing 903. 昂贵的聘礼 可以。AcWing 346. 走廊泼水节 可以。AcWing 393. 雇佣收银员 可以。AcWing 164. 可达性统计 可以。AcWing 341. 最优贸易 可以。AcWing 343. 排序 可以。AcWing 1170. 排队布局 可以。
Acwing提高课 --图论
qq_51968155的博客
04-27 398
图论 Dijkstra 时间复杂度：mlognmlognmlogn 边权：非负 性质：按照dijkstra更新的点时满足拓扑序的。 dijkstra求次短路 例题：观光 int dijkstra() { mem(dist, 0x3f); mem(st, false); mem(cnt, 0); dist[s][0] = 0; cnt[s][0] = 1; priority_queue<Node, vector<Node>, greater<Node>&gt
【图论】—— 最近公共祖先（LCA）
forever_bryant的博客
06-16 2160
【图论】—— 最近公共祖先（LCA）
acwing-提高课
二哈
08-22 1万+
目录 线段树 线段树 1275 最大数（python3 不带有懒标记的线段树）
ACM算法讲解（图论）--马新娟（82页）.pdf
09-07
图论的应用非常广泛，包括计算机科学、信息学、数据结构、算法设计等领域。在计算机科学中，图论是解决许多问题的基础，例如图的遍历、最小生成树、最短路径、关键路径、拓扑排序等。 图论的重要性体现在： 1. ...
AcWing 基础算法课.md
10-11
AcWing 基础算法课.md
acwing基础算法模板整理
02-27
这个"acwing基础算法模板整理"提供的资源很可能包含了这些领域的实例代码、解题思路和技巧，对于学习者来说，通过实践这些模板，不仅可以加深理论理解，还能提高编程能力，有助于在ACM/ICPC等编程竞赛或者实际开发中...
C++中的reverse()函数
热门推荐
YMWM_的博客
04-06 7万+
实现翻转数组，字符串，向量！ 1翻转数组 //头文件 #include <algorithm> //使用方法 reverse(a, a+n);//n为数组中的元素个数 示例代码， #include <iostream> #include <algorithm> using namespace std; void MyShow(int a[], int n) { for(int i = 0; i < n; i++) cout <&l
结构体排序的三种方式
YMWM_的博客
03-23 1万+
结构体排序方法
C++中如何查询map中是否存在某个元素
YMWM_的博客
04-06 9869
//1 利用count #include <unordered_map> unordered_map<string, int> dist; dist.count(x) == 1;//x元素存在 dist.count(x) == 0;//x元素不存在 //2 利用find dist.find(x) != dist.end();//x元素存在 dist.find(x) == dist.end();//x元素不存在 //3 利用迭代器遍历 unordered_map<string,
c++保留两位有效数字和保留小数点后两位
YMWM_的博客
04-30 4359
  演示代码如下： #include <iostream> #include <iomanip> using namespace std; int main() { double a = 123.345; cout << "正常输出为：" << a << endl; cout << "保留两位有效数字：" << setprecision(2) << a <&
二叉排序树中查找最近公共祖先的算法设计
在本篇关于“二叉排序树最近公共祖先”的文章中，主要讨论了如何在已构建的二叉排序树中寻找任意两个不同节点的最近公共祖先。二叉排序树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的所有节点值，且小于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YMWM_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值