最近公共祖先练习

最新推荐文章于 2024-10-01 23:05:47 发布
最新推荐文章于 2024-10-01 23:05:47 发布
阅读量73 收藏
点赞数
文章标签： 算法 c++ 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52255583/article/details/126083345
版权
  • 洛谷P2420 让我们异或吧
  • 思路

  • 这道题的思路和上道题类似都是需要一个树上前缀和 + lca,只不过这个是异或前缀和.

  • 代码:
#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 1e5 + 100,M = 2e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;
int d[N],a[N],fa[N][20];
int h[N],ne[M],e[M],w[M],idx,y[N];
void add(int a,int b,int c)
{
	e[idx] = b; w[idx] = c;ne[idx] = h[a],h[a] = idx++;
}
void bfs()
{
	queue<int> q; q.push(1); d[1] = 1;
	while(q.size())
	{
		int t = q.front();q.pop();
		for(int i = h[t];i != -1;i = ne[i])
		{
			int j = e[i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				q.push(j);
				fa[j][0] = t;
				y[j] = y[t] ^ w[i];
				for(int k = 1;k <= 19;k ++ ) fa[j][k] = fa[fa[j][k - 1]][k - 1];
			}
		}
	} 
}

int lca(int u,int v)
{
	if(d[u] < d[v]) swap(u,v);
	for(int i = 19;i >= 0;i -- )
	{
		if(d[fa[u][i]] >= d[v])
		u = fa[u][i];
	}
	
	if(u == v) return u;
	
	for(int i = 19;i >= 0;i -- )
	{
		if(fa[u][i] != fa[v][i])
		{
			u = fa[u][i];v = fa[v][i];
		}
	}
	
	return fa[u][0];
}
void solve()
{
	int n,m;cin >> n; memset(h,-1,sizeof h);
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v,c; cin >> u >> v >> c;
		add(u,v,c);add(v,u,c);
	}
	cin >> m; 
	bfs();
	while(m -- )
	{
		int u,v; cin >> u >> v;
		int anc = lca(u,v);
		int ans = y[u] ^ y[anc] ^ y[v] ^ y[anc]; // 我们可以发现y[anc] ^ y[anc] = 0,所以其实这道题不用求anc省略lca就行 直接算就好了
		cout << ans << endl;
	}
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}``
  • P3938 斐波那契
  • 思路

  • 范围为1e12,所以建图是不可能的,就只能靠硬方法做,二分 + lca,先求出他们在图上面的层数然后让他们处于一层,然后再同时向上走,直到两个点相等,难点在于求u 的父节点v,我们用 f 数组来表示原斐波那契数列,那 u 的父亲就是 u - f[k - 1] ,k 就是u 对应 f 数组里面的下标

  • 代码
#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 3e5 + 100,M = 2e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;
int f[100];

int lca(int u,int v)
{	
	if(u == v) return u;
	int k1 = lower_bound(f + 1,f + 1 + 60,u) - f;
	int k2 = lower_bound(f + 1,f + 1 + 60,v) - f;
	return lca(u - f[k1 - 1],v - f[k2 - 1]);	
}
int level(int x)
{
	int d = 1;
	while(x != 1)
	{
		int k1 = lower_bound(f + 1,f + 1 + 60,x) - f;
		x = x - f[k1 - 1];
		d++;
	}
	
	return d;
}

void solve()
{

	int n;cin >> n; 
	f[1] = 1,f[0] = 1;
	for(int i = 2;i <= 60;i ++ ) f[i] = f[i - 1] + f[i - 2];
	for(int i = 1;i <= n;i ++ )
	{
		int u,v; cin >> u >> v; // 先判断第几层
		int d1 = level(u), d2 = level(v);
	
		if(d1 > d2) // 不断的让d1往上面走 
		{
			while(d1 > d2)
			{
				int k = lower_bound(f + 1,f + 1 + 60,u) - f;
				u = u - f[k - 1];
				d1 --;
			} 
		}
		 if(d1 < d2) // 不断的让d2让上面走 
		{
			while(d2 > d1)
			{
				int k = lower_bound(f + 1,f + 1 + 60,v) - f;
				v = v - f[k - 1];
				d2 --;
			} 
		}
		
		cout << lca(u,v) << endl;
	}

	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
  • 洛谷P1351 [NOIP2014 提高组] 联合权值
  • 思路

  • 这道题也没有用到 lca 啊,(是我太菜???),这道题每一个节点都只有两种状态,第一种是爷孙节点,第二种是兄弟节点.关于爷孙节点就好求一点直接一个数组记录一下,关于兄弟节点的话,对于最大值的求值,只用记录最大权值和次大的权值,然后相乘与ans取一个最大值,求和的话有公式就是 所有兄弟节点的权值和的平方 - 每一个兄弟节点的权值平方 这个我没有想到,想到的是用前缀和求了一下比如求 a b c d 就是 d(a + b + c) + c(a + b) + ab 就用前缀和记录一下

  • 前缀和代码
#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 2e5 + 100,M = 4e5 + 100,mod = 10007,INF = 0x3f3f3f3f;
int fa[N][2];
int d[N],w[N];
vector<int> res[N];
int sum,ans = -INF;

void bfs()
{
	queue<int> q; q.push(1);
	d[1] = 1;
	
	while(q.size())
	{
		int t = q.front();q.pop();
		int mx1 = 0,mx2 = 0,cnt = 0;
	
		
		vector<int> s(res[t].size() + 1);
		s[0] = 0;
		
		
		for(int i = 0; i < res[t].size(); i ++ )
		{
			int j = res[t][i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				q.push(j);
				fa[j][0] = t;
				fa[j][1] = fa[fa[j][0]][0];
				sum = (sum + w[fa[j][1]] * w[j]) % mod;
				ans = max(ans,w[fa[j][1]] * w[j]);
				if(res[t].size() >= 3)
				{
					if(w[j] >= mx1)
					{
						mx2 = mx1;
						mx1 = w[j];
					}
					else if(w[j] > mx2)
					{
						mx2 = w[j];
					}
					++cnt;
					s[cnt] = s[cnt - 1] + w[j];	
				}
			
			}
		}
		
		if(res[t].size() >= 3)
		{
			ans = max(ans,mx2 * mx1);
		}
		
		for(int i = 1;i <= cnt - 1;i ++ )
		sum = (sum + (s[i + 1] - s[i]) * s[i]) % mod;
	}
	
	
}
void solve()
{
	int n; cin >> n;
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		res[u].pb(v);res[v].pb(u);
	}
	for(int i = 1;i <= n;i ++ ) cin >> w[i];
	
	bfs();
	
	cout << ans << ' ' << sum * 2 % mod << endl;
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
  • 公式代码
#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 2e5 + 100,M = 4e5 + 100,mod = 10007,INF = 0x3f3f3f3f;
int fa[N][2];
int d[N],w[N];
vector<int> res[N];
int sum,ans = -INF;

void bfs()
{
	queue<int> q; q.push(1);
	d[1] = 1;
	
	while(q.size())
	{
		int t = q.front();q.pop();
		int mx1 = 0,mx2 = 0,cnt = 0;
		int sc = 0,sc2 = 0;
		for(int i = 0; i < res[t].size(); i ++ )
		{
			int j = res[t][i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				q.push(j);
				fa[j][0] = t;
				fa[j][1] = fa[fa[j][0]][0];
				sum = (sum + w[fa[j][1]] * w[j] * 2) % mod;
				ans = max(ans,w[fa[j][1]] * w[j]);
				if(res[t].size() >= 3)
				{
					if(w[j] >= mx1)
					{
						mx2 = mx1;
						mx1 = w[j];
					}
					else if(w[j] > mx2)
					{
						mx2 = w[j];
					}
					sc = (sc + w[j]) % mod;
					sc2 = (sc2 + w[j] * w[j]) % mod;
				}
			}
		}
		
		if(res[t].size() >= 3)
		{
			sum = (sum + ((sc * sc) - sc2)) % mod;
			ans = max(ans,mx1 * mx2);
		}
		
	}
	
	
}
void solve()
{
	int n; cin >> n;
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		res[u].pb(v);res[v].pb(u);
	}
	for(int i = 1;i <= n;i ++ ) cin >> w[i];
	
	bfs();
	
	cout << ans << ' ' << sum << endl;
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
  • P4281 [AHOI2008]紧急集合 / 聚会
  • 思路

  • 因为是3个点,所以一共有3个lca,可以发现有两个lca是一定相等的,那就把点放在不是相等的那个点上面,要想走的最短那一定需要尽量不要走重复,如果把点放在lca相等的那个点上面就一定会有重复,所以也是要把点放在尽可能深的lca的那个点上面,这样可以减少重复,这道题自己写的时候考虑到了这一点,但是自己直接用了深度计算,忘记了人家可能也是弯曲的,少计算了一部分(菜鸡)

  • 代码
#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 5e5 + 100,M = 4e5 + 100,mod = 10007,INF = 0x3f3f3f3f;
int fa[N][20];
int d[N],w[N];
vector<int> res[N];
void bfs()
{
	queue<int> q; q.push(1);
	d[1] = 1;
	
	while(q.size())
	{
		int t = q.front();q.pop();
		for(int i = 0;i < res[t].size();i ++ )
		{
			int j = res[t][i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				q.push(j);
				fa[j][0] = t;
				for(int k = 1;k <= 19;k ++ )
				fa[j][k] = fa[fa[j][k - 1]][k - 1];
			}
		}
	}	
}

int lca(int u,int v)
{
	if(d[u] < d[v]) swap(u,v);
	for(int i = 19;i >= 0;i -- )
	{
		if(d[fa[u][i]] >= d[v])
		{
			u = fa[u][i];
		}
	}
	
	if(u == v) return u;
	
	for(int i = 19;i >= 0;i -- )
	{
		if(fa[u][i] != fa[v][i])
		u = fa[u][i],v = fa[v][i];
	}
	
	return fa[u][0];
}

void solve()
{
	int n,m; cin >> n >> m;
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		res[u].pb(v);res[v].pb(u);
	}
	bfs();
	while(m -- )
	{
		int a,b,c; cin >> a >> b >> c;
		int anc1 = lca(a,b),anc2 = lca(a,c),anc3 = lca(b,c);
		int ans,sum = 0;
	//	cout << anc3 << endl;
		if(d[anc1] >= d[anc2] && d[anc1] >= d[anc3])
		{
			if(d[anc2] >= d[anc3])
			{
				sum = d[a] + d[b] + d[c] - d[anc1] - d[anc3] * 2;
				ans = anc1;
			}
			else
			{
				sum = d[a] + d[b] + d[c] - d[anc1] - d[anc2] * 2;
				ans = anc1;
			}
		}
		else if(d[anc2] >= d[anc1] && d[anc2] >= d[anc3])
		{
			if(d[anc1] >= d[anc3])
			{
				sum = d[a] + d[b] + d[c] - d[anc2] - d[anc3] * 2;
				ans = anc2;
			}
			else
			{
				sum = d[a] + d[b] + d[c] - d[anc2] - d[anc1] * 2;
				ans = anc2;
			}
		}
		else if(d[anc3] >= d[anc2] && d[anc3] >= d[anc1])
		{
			if(d[anc2] >= d[anc1])
			{
				sum = d[a] + d[b] + d[c] - d[anc3] - d[anc1] * 2;
				ans = anc3;
			}
			else
			{
				sum = d[a] + d[b] + d[c] - d[anc3] - d[anc2] * 2;
				ans = anc3;
			}
		}
		
		
		cout << ans << ' ' << sum << endl; 
	}
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
努力码字中...
关注
树的直径与最近公共祖先（LCA）
m0_55341679的博客
11-13 243
树的直径与LCA
JAVA练习121- II. 二叉树的最近公共祖先
qq_48772498的博客
02-14 299
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树:root =[3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和...
最近公共祖先(LCA)详解
m0_74732859的博客
04-24 1274
1.前言 公共祖先问题是指在一个树结构中，找到两个节点的最近公共祖先（Lowest Common Ancestor, LCA）。公共祖先指的是两个节点的某个祖先节点，而最近公共祖先则指的是离这两个节点最近的共同的祖先节点
【算法训练-二叉树 五】【最近公共祖先】二叉树的最近公共祖先、二叉搜索树的最近公共祖先
MaoLin Tian's Blog
09-21 363
废话不多说，喊一句号子鼓励自己：程序员永不失业，程序员走向架构！本篇Blog的主题是【二叉树的节点查找】，使用【二叉树】这个基本的数据结构来实现，这个高频题的站点是：[**CodeTop**](https://codetop.cc/home)，筛选条件为：**目标公司+最近一年+出现频率排序**，由高到低的去[**牛客TOP101**](https://www.nowcoder.com/exam/oj?page=1&tab=%E7%AE%97%E6%B3%9
图论--最近公共祖先LCA
信息学奥赛学案
07-08 2080
求最近公共祖先LCA的三种方法
最近公共祖先问题
m0_62652820的博客
07-20 796
最近公共祖先的倍增法、Tarjan算法等等
LCA最近公共祖先
m0_58642116的博客
01-04 539
LCA
lca 最近公共祖先
weixin_60600142的博客
07-17 309
对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u和v的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先。（摘自百度百科下面是个例子：fill:#333;color:#333;color:#333;fill:none;1234567。
使用C语言求二叉树结点的最低公共祖先的方法
09-03
在二叉树中，最低公共祖先（Lowest Common Ancestor, LCA）是指在树中同时是两个给定节点的最近的共同祖先。本篇主要介绍如何使用C语言求解二叉树节点的最低公共祖先，并结合ACM的练习题目进行深入解析。 首先，...
python入门-leetcode面试题解之第236题二叉树的最近公共祖先.zip
05-31
本资料包“python入门-leetcode面试题解之第236题二叉树的最近公共祖先.zip”正专注于这个方向，旨在帮助初学者解决LeetCode中的面试难题。 LeetCode是一个知名的在线平台，提供各种算法问题供用户练习和提高，它...
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1274
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 463
25[0, 105]
904. 水果成篮
YQ20210216的博客
09-27 361
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 786
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 337
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1270
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
python 实现linear discriminant analysis线性判别分析算法
luthane的博客
09-26 522
线性判别分析（Linear Discriminant Analysis，简称LDA）是一种用于降维和分类的监督学习算法。它通过最大化类间散度和最小化类内散度来找到最佳投影方向，使得不同类别的数据在新的空间中尽可能分开，同一类别的数据尽可能靠近。LDA的基本思想LDA的基本思想是将多维数据映射到低维空间，同时保留数据之间的类别差异。具体来说，LDA通过计算类内散度矩阵（描述同一类别内部数据的分布情况）和类间散度矩阵（描述不同类别之间的差异），然后求解这两个矩阵的广义特征值问题，找到最佳的投影方向。
LeetCode解题策略：二叉树最近公共祖先与数组乘积
二叉树的最近公共祖先和238.除自身以外数组的乘积。" 在LeetCode的热门题目中，我们经常会遇到一些挑战性的算法问题，这些问题能够帮助我们提升编程和数据结构理解能力。以下是这两道题目的详细解析： **236. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值