乐师理工ACM集训 - LCA

最新推荐文章于 2021-10-03 23:52:27 发布
最新推荐文章于 2021-10-03 23:52:27 发布
阅读量192 收藏 1
点赞数 1
分类专栏： 2020暑假集训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45309822/article/details/107946706
版权

文章目录

HDU2586 How far away ？

传送门：HDU2586 How far away ？

题目大意

  T个测试样例，每个测试样例给定一个N（N间房屋）和M（M个查询），接下来N-1行会给出三个数i，j，k，表示房间 i 到房间 j 的距离为 k。再接下来M行分别会给出两个数，表示需要查询的两个房屋。(T<=10，2<=n<=40000，1<=m<=200，0<k<=40000）
  道路的建造方式是每两栋房屋之间都有一条唯一的简单路径（“简单”意味着您不能两次访问某个地方）
  问：对于M个询问，每个询问的两个房屋之间的距离为多少？

解题思路

  求树上两点距离可用LCA求解。

distance(u,v) = dis[u] + dis[v] - 2 * dis[LCA(u,v)]
其中 distance 是树上两点间的距离，dis 代表某点到树根的距离。

AC代码【倍增 + LCA】

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 4e4 + 5;
const int MAXM = 4e4 + 5;
const int INF = 0x3f3f3f3f;
int n,m,node,N;
int head[MAXN],dp[MAXN][30],deep[MAXN],dis[MAXN];
struct Node {
    int to,w,pre;
}edge[MAXM << 1];
void init() {
    memset(head, -1, sizeof(head));
    memset(dp, 0, sizeof(dp));
    memset(dis, 0, sizeof(dis));
    memset(deep, 0, sizeof(deep));
    node = 0;
    N = (int)log2(n);
}
void add_edge(int u, int v, int w) {
    edge[node].to = v;
    edge[node].w = w;
    edge[node].pre = head[u];
    head[u] = node++;
}
void dfs(int now, int fa) {
    dp[now][0] = fa;
    for (int i = 1; (1 << i) <= deep[now]; i++) {
        dp[now][i] = dp[dp[now][i - 1]][i - 1];
    }
    for (int i = head[now]; ~i; i = edge[i].pre) {
        int v = edge[i].to;
        if (v != fa) {
            deep[v] = deep[now] + 1;
            dis[v] = dis[now] + edge[i].w;
            dfs(v,now);
        }
    }
}
int lca(int u, int v) {
    if (deep[u] < deep[v]) {
        swap(u,v);
    }
    int h = deep[u] - deep[v];
    for (int i = 0, j = (1 << i); j <= h; i++, j  = (1 << i)) {
        if (h & j) {
            u = dp[u][i];
        }
    }
    if (u == v) {
        return u;
    }
    for (int i = N; i >= 0; i--) {
        if (dp[u][i] != dp[v][i]) {
            u = dp[u][i];
            v = dp[v][i];
        }
    }
    return dp[u][0];
}
void solve() {
    int u,v,w;
    scanf("%d%d",&n,&m);
    init();
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    dfs(1,0);
    for (int i = 0; i < m; i++) {
        scanf("%d%d",&u,&v);
        printf("%d\n",dis[u] + dis[v] - 2 * dis[lca(u,v)]);
    }
}

int main() {   
    int T;
	cin >> T;
	for (int i = 1; i <= T; i++) {
		solve();
	}
    return 0;
}

HDU2874 Connections between cities

传送门：HDU2874 Connections between cities

题目大意

  n个城市，m条路，c个查询（2<=n<=10000, 0<=m<10000, 1<=c<=1000000）。两个城市之间可能没有道路，也无环。问：两个城市之间是否存在道路，如果不存在输出"Not connected"，否则输出最短路径。

解题思路

  求森林中两点距离。还是可以用LCA，但是需要额外判断两点是否连通。
  判断两点是否连通一般是使用并查集维护集合。但是这里我们在使用LCA预处理dp数组时已经记录了某个结点的父亲结点是谁，当某个结点父亲结点是0时，说明它不在已知集合之中，则可以以它为根继续dfs建树。
  当查询LCA时，如果两个点的LCA（u，v） == 0，说明这两个点在不同集合，那么自然也就不连通了。
在这里插入图片描述

AC代码【倍增 + LCA】

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e4 + 5;
const int MAXM = 1e4 + 5;
const int INF = 0x3f3f3f3f;
int n,m,c,node,N;
int head[MAXN],dp[MAXN][30],deep[MAXN];
ll dis[MAXN];
struct Node {
    int to,w,pre;
}edge[MAXM << 1];
void init() {
    memset(head, -1, sizeof(head));
    memset(dp, 0, sizeof(dp));
    memset(dis, 0, sizeof(dis));
    memset(deep, 0, sizeof(deep));
    node = 0;
    N = (int)log2(n);
}
void add_edge(int u, int v, int w) {
    edge[node].to = v;
    edge[node].w = w;
    edge[node].pre = head[u];
    head[u] = node++;
}
void dfs(int now, int fa) {
    dp[now][0] = fa;
    for (int i = 1; (1 << i) <= deep[now]; i++) {
        dp[now][i] = dp[dp[now][i - 1]][i - 1];
    }
    for (int i = head[now]; ~i; i = edge[i].pre) {
        int v = edge[i].to;
        if (v != fa) {
            deep[v] = deep[now] + 1;
            dis[v] = dis[now] + edge[i].w;
            dfs(v,now);
        }
    }
}
int lca(int u, int v) {
    if (deep[u] < deep[v]) {
        swap(u,v);
    }
    int h = deep[u] - deep[v];
    for (int i = 0, j = (1 << i); j <= h; i++,j  = (1 << i)) {
        if (h & j) {
            u = dp[u][i];
        }
    }
    if (u == v) {
        return u;
    }
    for (int i = N; i >= 0; i--) {
        if (dp[u][i] != dp[v][i]) {
            u = dp[u][i];
            v = dp[v][i];
        }
    }
    return dp[u][0];
}
void solve() {
    int u,v,w;
    while (~scanf("%d%d%d",&n,&m,&c)) {
        init();
        for (int i = 0; i < m; i++) {
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        for (int i = 1; i <= n; i++) {
            if (!dp[i][0]) {
            	// 点 i 不在已知集合中，以 i 为根 dfs 建树
                dfs(i,0);
            }
        }
        for (int i = 0; i < c; i++) {
            scanf("%d%d",&u,&v);
            int  l = lca(u,v);
            if (l == 0) {
            	// lca(u, v) == 0 说明 u，v不在同一个集合，即不连通
                puts("Not connected");
            } else {
                printf("%lld\n",dis[u] + dis[v] - 2 * dis[l]);
            }
        }
    }
}
int main() {   
    solve();
    return 0;
}

CodeForces1328E Tree Queries

传送门：CodeForces1328E Tree Queries

题目大意

  给你n个顶点n-1条边的树，然后有m个查询，查询由一个数k和k个数组成，问是否存在从根到某个顶点u的路径，以使给定的k个顶点中的每个顶点都属于该路径，或者与该路径上的某个顶点之间的距离为1。

解题思路

  对于题目要求的路径，可以看做以根结点为起点，深度最深的点为终点，然后判断其他点是否在这条路径上，或者距离这条路径上某个点距离为1。
  怎么判断呢？找到某个点u和深度最深的点v的LCA(u,v)，他们的LCA(u,v)必定在路径上，那么当deep[u] - deep[LCA(u,v)] <= 1时，就说明点u在路径上（u == LCA(u,v)）或者离路径上的点距离为1。 当所有的点u都满足条件时为YES，有一个点不满足则为NO。

AC代码【倍增 + LCA + 思维】

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;
const int MAXM = 2e5 + 5;
const int INF = 0x3f3f3f3f;
int n,m,c,node,N;
int head[MAXN],dp[MAXN][30],deep[MAXN],a[MAXN];
struct Node {
    int to,pre;
}edge[MAXM << 1];
void init() {
    memset(head, -1, sizeof(head));
    memset(dp, 0, sizeof(dp));
    memset(deep, 0, sizeof(deep));
    node = 0;
    N = (int)log2(n);
}
void add_edge(int u, int v) {
    edge[node].to = v;
    edge[node].pre = head[u];
    head[u] = node++;
}
void dfs(int now, int fa) {
    dp[now][0] = fa;
    for (int i = 1; (1 << i) <= deep[now]; i++) {
        dp[now][i] = dp[dp[now][i - 1]][i - 1];
    }
    for (int i = head[now]; ~i; i = edge[i].pre) {
        int v = edge[i].to;
        if (v != fa) {
            deep[v] = deep[now] + 1;
            dfs(v,now);
        }
    }
}
int lca(int u, int v) {
    if (deep[u] < deep[v]) {
        swap(u,v);
    }
    int h = deep[u] - deep[v];
    for (int i = 0, j = (1 << i); j <= h; i++,j  = (1 << i)) {
        if (h & j) {
            u = dp[u][i];
        }
    }
    if (u == v) {
        return u;
    }
    for (int i = N; i >= 0; i--) {
        if (dp[u][i] != dp[v][i]) {
            u = dp[u][i];
            v = dp[v][i];
        }
    }
    return dp[u][0];
}
void solve() {
    int u,v,k;
    while (~scanf("%d%d",&n,&m)) {
        init();
        for (int i = 1; i < n; i++) {
            scanf("%d%d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs(1,0);
        for (int i = 0; i < m; i++) {
            scanf("%d",&k);
            // vertices 存储深度最深的结点
            int vertices = 0;
            for (int j = 0; j < k; j++) {
                scanf("%d",&a[j]);
                if (deep[a[j]] > deep[vertices]) {
                    vertices = a[j];
                }
            }
            int flag = 1;
            for (int j = 0; j < k; j++) {
                int l = lca(a[j],vertices);
                // 点 a[j] 到路径上的点距离大于 1，不符合题意
                if (deep[a[j]] - deep[l] > 1) {
                    puts("NO");
                    flag = 0;
                    break;
                }
            }
            if (flag) {
                puts("YES");
            }
        }
    }
}

int main() {   
    solve();
    return 0;
}

CodeForces1304E 1-Trees and Queries

传送门；CodeForces1304E 1-Trees and Queries

题目大意

  给你有n个顶点n-1条边的树，然后有q个查询。 每个查询包含5个整数：x，y，a，b和k。 意为在顶点x和y之间添加双向边后，问是否存在从顶点a到b的路径，该路径恰好包含k个边。 路径可以多次包含相同的顶点和相同的边。 所有查询彼此独立，也就是说，在下一个查询时删除了以往查询添加的边。

解题思路

  对于给定的询问，可能存在三种路径：
  1、a->b
  2、a->x->y->b
  3、a->y->x->b
  对于三条路径任意一条满足距离小于等于k且和k同奇偶性为YES，三条都不满足为NO。
  距离小于等于k且同奇偶性是为了可以反复走某一路径使得凑够k条边。

AC代码【倍增 + LCA + 思维】

#include<bits/stdc++.h>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e5 + 5;
const int MAXM = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int n,m,c,node,N;
int head[MAXN],dp[MAXN][30],deep[MAXN],a[MAXN];
struct Node {
    int to,pre;
}edge[MAXM << 1];
void init() {
    memset(head, -1, sizeof(head));
    memset(dp, 0, sizeof(dp));
    memset(deep, 0, sizeof(deep));
    node = 0;
    N = (int)log2(n);
}
void add_edge(int u, int v) {
    edge[node].to = v;
    edge[node].pre = head[u];
    head[u] = node++;
}
void dfs(int now, int fa) {
    dp[now][0] = fa;
    for (int i = 1; (1 << i) <= deep[now]; i++) {
        dp[now][i] = dp[dp[now][i - 1]][i - 1];
    }
    for (int i = head[now]; ~i; i = edge[i].pre) {
        int v = edge[i].to;
        if (v != fa) {
            deep[v] = deep[now] + 1;
            dfs(v,now);
        }
    }
}
int lca(int u, int v) {
    if (deep[u] < deep[v]) {
        swap(u,v);
    }
    int h = deep[u] - deep[v];
    for (int i = 0, j = (1 << i); j <= h; i++,j  = (1 << i)) {
        if (h & j) {
            u = dp[u][i];
        }
    }
    if (u == v) {
        return u;
    }
    for (int i = N; i >= 0; i--) {
        if (dp[u][i] != dp[v][i]) {
            u = dp[u][i];
            v = dp[v][i];
        }
    }
    return dp[u][0];
}
int dis(int u, int v) {
    return deep[u] + deep[v] - 2 * deep[lca(u,v)];
}
bool check(int len, int k) {
    return (len <= k) && (len % 2 == k % 2);
}
void solve() {
    int u,v,x,y,a,b,k;
    while (~scanf("%d",&n)) {
        init();
        for (int i = 1; i < n; i++) {
            scanf("%d%d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs(1,0);
        scanf("%d",&m);
        for (int i = 0; i < m; i++) {
            scanf("%d%d%d%d%d",&x,&y,&a,&b,&k);
            if (check(dis(a,b),k) || check(dis(x,a) + dis(y,b) + 1,k) || check(dis(y,a) + dis(x,b) + 1,k)) {
                puts("YES");
            } else {
                puts("NO");
            }
        }
    }
}

int main() {   
    solve();
    return 0;
}
勿忘∮心安
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈尔滨理工大学ACM-ICPC 集训队
03-16
哈尔滨理工大学ACM-ICPC 集训队 —— 哈尔滨理工大学ACM培训资料汇编-基本算法与数据结构 内容也挺全的挺有用的。。
ACM模板 -- WarBlood.pdf
05-20
acm模板，适合菜鸡使用
ACM——LCA
weixin_40446193的博客
05-10 364
一、算法定义 LCA是在线查询树上两点的最近公共祖先的算法，可运用倍增的方法，时间复杂组O（nlogn） 二、算法过程 1.倍增使深度较深的点跳到和深度较浅的点同一深度。 2.两个点一起往上跳，直到找到公共祖先 三、模板 //预处理：通过dfs，求出树上每个节点的深度。注：p[x][0]是x的父节点，如果遍历到父节点则跳过，其他的与该点相邻的点都是他的子节点 void dfs(int x) { ...
acm算法之lca最近公共祖先
qq_52511089的博客
10-03 230
//lca（求最小公共祖先） 此处考虑使用最简单的被增法解决最近公共祖先问题 #include<stdio.h> #include<string.h> struct edge { int to,next; }edge[1000]; int cnt,head[1000],lg[1000]; void add(int x,int y)//链式前向星存边，即存图 { edge[++cnt].to=y; edge[cnt].next=head[x]; head[x]=cnt; }.
ACM模板——LCA
weixin_30276935的博客
09-25 160
1 #include <bits/stdc++.h> 2 #define _for(i,a,b) for(int i = (a);i < b;i ++) 3 #define _rep(i,a,b) for(int i = (a);i > b;i --) 4 #define INF 0x3f3f3f3f 5 #define pb push_...
挑战 LCA 学习以及个人理解
Haipai1998的博客
08-21 420
因为学的比较浅，直接上模板，有不足的地方请指正·-·！ 既然要学LCA，那我们要明白LCA,是怎么定义的，怎么确定哪个是LCA。 LCA 被称为 最近公共祖先。 下面只介绍一种方法——倍增法【我不会说我只学了一种的】 。 先写个大致的思路：接下来是按照这样的思路放模板。首先脑海里浮想出一棵树，然后节点u,v。OK ， 可以开始放模板了。这题输入针对，可以一边看那题一边看模板
ACM LCA 倍增 模板 HDU 5044
nickwong & nickwang
09-27 1347
LCA 倍增模板O(N*log N),N为点数 最近公共祖先
ACM题集-ACM训练题集-超多ACM题集汇总-解题源码
01-17
ACM题集_ACM训练题集_超多ACM题集汇总_解题源码
ACMICPC-Latex模板：一个简单的ACM-ICPC（LaTeX）模板生成器
02-04
一个简单的ACM-ICPC模板生成器 一个非常简单的ACM-ICPC代码模板生成工具。 从源代码目录生成模板而无需将其复制到docx或tex文件，仅需执行一条命令。 您只需要做的就是使用python gen.py生成模板PDF文件。 要求 ...
北京大学暑期ACM集训资料
09-25
北京大学暑期ACM集训资料,包含数据结构，搜索专题，动态规划，数学专题，最短路，计算几何，二分，分治以及强连通分量等等
RMQ与LCA ACM必备
09-27
RMQ与LCA ACM必备RMQ与LCA ACM必备 RMQ与LCA ACM必备
乐师理工ACM集训-深搜和广搜
Lucas9的博客
07-28 278
文章目录HDU1241 Oil Deposits【DFS】题目大意解题思路AC代码HDU1548 A strange lift【BFS】题目大意解题思路AC代码POJ1321 棋盘问题AC代码HDU1978 How many waysAC代码1【记忆化搜索】AC代码2【dp】数的划分AC代码1【DFS】AC代码2【dp】HDU1253 胜利大逃亡【三维BFS】解题思路AC代码 HDU1241 Oil Deposits【DFS】 传送门：HDU1241 Oil Deposits 题目大意   问有多少个油田（
2019/12/07 乐山师范学院程序设计大赛—F 整数的最优变换
Lucas9的博客
12-12 314
问题 F: 整数的最优变换 时间限制: 1 Sec内存限制: 128 MB 题目链接：http://acm.lsnu.edu.cn/oj/problem.php?id=2493 题目描述 给定一个整数 n，这里定义了如下操作： 如果 n 能被 2 整除，n = n / 2; 如果 n 能被 3 整除，n = 2 * n / 3; 如果 n 能被 5 整除，n = 4 * n /...
ACM_lca
final dream
11-21 1382
前言 lca(Least Common Ancestors) : 最近公共祖先, 一般题目的是给你一棵树(当然也有些题不会直接给你)题目的解法大多会让你向上找两个点的最近公共祖先, 比如上图的4 和 5的公共祖先是2, 9 和 7 的公共祖先是3, 3 和 8的公共祖先是3, 搭配的可能就还有一些其他的问题, 比如两点间的最短距离(边有权值, 而且边的权值可能会变) 或者搭配树形DP类似的东西
acm-(交互、随机、完全二叉树、lca)CF Difficult Problems Olha and Igor
qq_30361651的博客
11-22 205
传送门 首先有个结论：以www为根的lca(u,v)lca(u,v)lca(u,v)是到u,v,wu,v,wu,v,w三点距离和最小的点。结论显然正确，证明略。 我们考虑所有满足ask(u,v,w)≠u,v,wask(u,v,w)\ne u,v,wask(u,v,w)​=u,v,w的三元组(u,v,w)(u,v,w)(u,v,w)，对于d=ask(u,v,w)d=ask(u,v,w)d=ask(u,v,w)而言，假设有cnt[d]cnt[d]cnt[d]个这样不同的三元组。假设dep[d]=i,i&gt.
乐师理工ACM集训 - 图的基本概念、深广搜、拓扑排序
Lucas9的博客
08-04 403
文章目录HDU2094 产生冠军【入度统计+字符串处理】解题思路AC代码HDU1285 确定比赛名次【优先队列+拓扑排序】解题思路AC代码HDU2647 Reward【反向建图+拓扑判环+统计 】题目描述解题思路AC代码HDU1181 变形课【建图+搜索】解题思路AC代码1【DFS】AC代码2【BFS】Codeforces780C Andryusha and Colored Balloons【建图+搜索】题目描述解题思路AC代码【DFS】 HDU2094 产生冠军【入度统计+字符串处理】 传送门：HDU20
基于Springboot+Vue的墙绘产品展示交易平台毕业源码案例设计.zip
最新发布
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
99-青海大学大数据中心建设分享.pptx
04-27
99-青海大学大数据中心建设分享.pptx
TD-LTE载波聚合方案.docx
04-27
5G通信行业、网络优化、通信工程建设资料。
ACM-ICPC模板整理
09-04
ACM-ICPC（国际大学生程序设计竞赛）是一项面向大学生的计算机编程竞赛，涉及算法和数据结构等领域。在比赛中，选手需要解决一系列编程问题，使用合适的算法和数据结构来实现正确和高效的解决方案。 对于整理ACM-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值