图论——树上前缀和和树上差分(LCA应用)

最新推荐文章于 2024-06-18 10:11:42 发布
最新推荐文章于 2024-06-18 10:11:42 发布
阅读量510 收藏 6
点赞数 9
分类专栏： 图论 文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/victor_hq/article/details/137262482
版权

树上前缀和和树上差分

树上前缀和

原理

在这里插入图片描述

应用

P4427 求和

P4427

在这里插入图片描述

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long LL;
const LL mod=998244353;
const int N=3e5+10,M=2*N; 
int n,m;
int h[N],to[M],ne[M],tot;
int fa[N][22];//fa[u][i]表示从u向上跳2^i层的祖先结点
int dep[N];   //dep[v]表示v的深度
LL mi[60];   //mi[j]表示dep[v]的j次幂
LL s[N][60]; //s[v][j]表示从根到v的路径节点的深度的j次幂之和

void add(int a, int b){ 
  to[++tot]=b,ne[tot]=h[a],h[a]=tot;
}
void dfs(int u, int f){ //预处理节点信息
  for(int i=1; i<=20; i++) 
    fa[u][i]=fa[fa[u][i-1]][i-1];
  for(int i=h[u];i;i=ne[i]){
    int v=to[i];
    if(v==f) continue;
    fa[v][0]=u; dep[v]=dep[u]+1;
    for(int j=1;j<=50;j++) mi[j]=mi[j-1]*dep[v]%mod;
    for(int j=1;j<=50;j++) s[v][j]=(mi[j]+s[u][j])%mod;
    dfs(v, u);
  }
}
int lca(int u, int v){ //倍增法求lca
  if(dep[u]<dep[v])swap(u, v);
  for(int i=20; ~i; i--)
    if(dep[fa[u][i]]>=dep[v]) u=fa[u][i];
  if(u==v) return v;
  for(int i=20; ~i; i--)
    if(fa[u][i]!=fa[v][i]) u=fa[u][i], v=fa[v][i];
  return fa[u][0];
}
int main(){
  scanf("%d",&n); 
  for(int i=1,a,b; i<n; i++){
    scanf("%d%d",&a,&b);
    add(a,b); add(b,a);
  }
  mi[0]=1; dfs(1, 0);
  
  scanf("%d",&m);
  for(int i=1,u,v,k;i<=m;i++){
    scanf("%d%d%d",&u,&v,&k);
    int l=lca(u,v);
    LL ans=(s[u][k]+s[v][k]-s[l][k]-s[fa[l][0]][k]+2*mod)%mod;
    printf("%lld\n",ans);
  }
}

树上差分

原理

在这里插入图片描述

应用

P3128 Max Flow P

P3128

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e4+10;
int n,k,x,y;
vector<int> e[N];
int fa[N][20],dep[N],diff[N];
int ans=-1;
void dfs(int u,int f){
	fa[u][0]=f,dep[u]=dep[f]+1;
	for(int i=1;i<=19;i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	for(auto v:e[u]){
		if(v!=f){
			dfs(v,u);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=19;i>=0;i--){
		if(dep[fa[u][i]]>=dep[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 dfs2(int u,int f){
	for(auto v:e[u]){
		if(v!=f){
			dfs2(v,u);
			diff[u]+=diff[v];
		}
	}
	ans=max(ans,diff[u]);
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	scanf("%d%d",&n,&k);//用scanf和printf比较好，
	for(int i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		e[x].push_back(y);
		e[y].push_back(x);
	}
	dfs(1,0);
	while(k--){
		scanf("%d%d",&x,&y);
		int l=lca(x,y);
		diff[x]++,diff[y]++,diff[l]--,diff[fa[l][0]]--;
	}
	dfs2(1,0);
	printf("%d",ans);
	return 0;
}

砍树(蓝桥杯真题）

传送门
在这里插入图片描述
本题思路：将树上区间加操作，最后统计每条边总和，这马上想到差分，因为是树上，所以使用树上差分

#include <iostream>
#include <algorithm>
#include <vector>
#include<map>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int maxn = 1e5 + 50;

vector<int> e[maxn];
ll fa[maxn], dep[maxn], son[maxn], siz[maxn], top[maxn];
ll diff[maxn];
map<pii,ll> id;
void dfs1(ll u, ll f) {
    fa[u] = f;
    dep[u] = dep[f] + 1;
    siz[u] = 1;
    for (auto x: e[u]) {
        ll v = x;
        if (v == f) continue;
        dfs1(v, u);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]]) son[u] = v;
    }
}

void dfs2(ll u, ll t) {
    top[u] = t;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (auto x: e[u]) {
        ll v = x;
        if (v != son[u] && v != fa[u]) dfs2(v, v);
    }
}

ll lca(ll x, ll y) {
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) swap(x, y);
        x = fa[top[x]];
    }
    return dep[x] > dep[y] ? y : x;
}

void dfs(int x, int fx) {
    for (auto y: e[x]) {
        if (y == fx) continue;
        dfs(y, x);
        diff[x] += diff[y];
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        e[u].emplace_back(v);
        e[v].emplace_back(u);
        id[{u,v}]=i;
        id[{v,u}]=i;
    }
    dfs1(1, 1);
    dfs2(1, 1);
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v;
        diff[u]++, diff[v]++, diff[lca(u, v)] -= 2;
    }
    dfs(1, 0);
    ll ans = -1;
    for (int i = 0; i <= n; i++){
        if (diff[i] >= m){
            ans=max(ans,id[{i,fa[i]}]);
        }
    }
    cout << ans << endl;
    return 0;
}

注意：以两个点存储边号，标记。边差分原理是，将边差分转换为点差分，除根节点外，每个点都代表点上面的那条边。

U143800 暗之连锁

传送门

在这里插入图片描述

难点：

1.当边累积超过1次，则说明删除此边不能形成满足条件，所以不会影响答案。
2.当累积为1次时，答案加一，删除此边和构成环的附加边。
3.当累积为0次时，答案加m，说明删除此边就满足条件，然后随便删除一条附加边即可。

然后用set存有哪些点，最好答案还要减去m，因为根节点为0，但是其不表示边。注意set适合去重，存点，但是有顺序的时候得慎重考虑，因为set会自动排序。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n,k,x,y;
vector<int> e[N];
set<int> st;
int fa[N][20],dep[N];
ll diff[N];
ll ans=0;
void dfs(int u,int f){
	fa[u][0]=f,dep[u]=dep[f]+1;
	for(int i=1;i<=19;i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	for(auto v:e[u]){
		if(v!=f){
			dfs(v,u);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=19;i>=0;i--){
		if(dep[fa[u][i]]>=dep[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 dfs2(int u,int f){
	for(auto v:e[u]){
		if(v!=f){
			dfs2(v,u);
			diff[u]+=diff[v];
		}
	}
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	scanf("%d%d",&n,&k);
	int m=k;
	for(int i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		e[x].push_back(y);
		e[y].push_back(x);
		st.insert(x);
		st.insert(y);
	}
	dfs(1,0);
	while(k--){
		scanf("%d%d",&x,&y);
		int l=lca(x,y);
		diff[x]++,diff[y]++,diff[l]-=2;
	}
	dfs2(1,0);
	for(auto x:st){
		if(diff[x]==1) ans++;
		else if(!diff[x]) ans+=m;
	}
	printf("%d",ans-m);
	return 0;
}

P3258 松鼠的新家

传送门
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+10;
int n,k,x,y;
vector<int> e[N];
int fa[N][22],dep[N],a,b,t[N];
ll diff[N];
ll ans=0;
void dfs(int u,int f){
	fa[u][0]=f,dep[u]=dep[f]+1;
	for(int i=1;i<=21;i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	for(auto v:e[u]){
		if(v!=f){
			dfs(v,u);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=21;i>=0;i--){
		if(dep[fa[u][i]]>=dep[v])
			u=fa[u][i];
	}
	if(u==v) return u;
	for(int i=21;i>=0;i--){
		if(fa[u][i]!=fa[v][i])
			u=fa[u][i],v=fa[v][i];
	}
	return fa[u][0];
}

void dfs2(int u,int f){
	for(auto v:e[u]){
		if(v!=f){
			dfs2(v,u);
			diff[u]+=diff[v];
		}
	}
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&t[i]);
	}
	for(int i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		e[x].push_back(y);
		e[y].push_back(x);
	}
	dfs(1,0);
	for(int i=1;i<n;i++){
		x=t[i-1],y=t[i];
		int l=lca(x,y);
		diff[x]++,diff[y]++,diff[l]--,diff[fa[l][0]]--;
	}
	dfs2(1,0);
	for(int i=1;i<n;i++) diff[t[i]]--;//要先减，看清楚题意要求的输出
	for(int i=1;i<=n;i++){
		printf("%d\n",diff[i]);
	}
	return 0;
}

P2680 运输计划

传送门

题意：让一条边长度(时间)变为0，求所有运输计划所需最大时间最小。求最大值最小——二分答案。

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=3e5+10,M=2*N;

int h[N],e[M],w[M],ne[M],idx;//链式向前星 
int fa[N],son[N],sz[N],top[N],dep[N];//树剖求最近公共祖先 
int n,m,R,L,cnt;//R表示最大航道飞行时间，L表示最大每条边的飞行时间
//diff树上差分数组，sum树上前缀和数组 
int diff[N],sum[N],dnf[N],val[N];//dnf从祖宗节点重新映射每个树节点，val[i]存储点i上面的边长度。 
void add(int a,int b,int c){
	e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
struct node{
	int u,v,l,d;//存储运输计划的两个端点和最近公共祖先节点，所需耗时时间 
}edge[N];

void dfs1(int u,int f,int len){//预处理除了top的数组，和前缀和数组 
	fa[u]=f,dep[u]=dep[f]+1,sz[u]=1,sum[u]=len,dnf[++cnt]=u;//dnf和val这个技巧要学会 
	for(int i=h[u];~i;i=ne[i]){
		int j=e[i];
		if(j==f) continue;
		dfs1(j,u,len+w[i]);
		val[j]=w[i];
		sz[u]+=sz[j];
		if(sz[son[u]]<sz[j]) son[u]=j;
	}
}

void dfs2(int u,int t){//预处理top数组，重链 
	top[u]=t;
	if(!son[u]) return;
	dfs2(son[u],t);
	for(int i=h[u];~i;i=ne[i]){
		int v=e[i];
		if(v==fa[u]||v==son[u]) continue;
		dfs2(v,v);
	}
}
int lca(int u,int v){
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		u=fa[top[u]];
	}
	return dep[u]<dep[v]?u:v;
}
void dfs3(int u){//树上差分求和 
	for(int i=h[u];~i;i=ne[i]){
		int v=e[i];
		if(v==fa[u]) continue;
		dfs3(v);
		diff[u]+=diff[v];
	}
}
bool check(int x){
	memset(diff,0,sizeof diff);
	int count=0;
	for(int i=1;i<=m;i++){
		if(edge[i].d>x){
			count++;
			int u=edge[i].u,v=edge[i].v,l=edge[i].l;
			diff[u]++,diff[v]++,diff[l]-=2;
		}
	}
	dfs3(1);
	for(int i=1;i<=n;i++){
		if(val[dnf[i]]>=R-x&&diff[dnf[i]]>=count)//有一条边长度大于等于缺少的部分，并且被覆盖次数大于count次 
			return true;
	}
	return false;
}
int main(){
	memset(h,-1,sizeof h);
	int a,b,c;
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c),add(b,a,c);
		L=max(L,c);
	}
	dfs1(1,0,0),dfs2(1,1);
	for(int i=1;i<=m;i++){
		scanf("%d%d",&a,&b);
		int l=lca(a,b);
		int d=sum[a]+sum[b]-sum[l]*2;
		edge[i]={a,b,l,d};
		R=max(R,d);
	}
	int l=R-L-1,r=R+1;
	while(l+1<r){
		int mid=l+r>>1;
		if(check(mid)) r=mid;
		else l=mid;
	} 
	printf("%d\n",r);
}

开心，一遍敲过，想代码时间应该占完成题目总时间的七成，想好了，bug才很少。
经验：
1.用点表示点上面边的长度
2.二分答案技巧。

策z
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LCA-树上差分.pdf
05-10
LCA_树上差分讲解PPT 详细易懂 ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！...
Tarjan应用LCA
07-15
Tarjan应用LCA
OI题目类型总结整理
weixin_30552811的博客
02-15 505
## 本蒟蒻的小整理qwq～～持续更新（咕咕咕） 数据结构 数据结构 知识点梳理 数据结构——线段树 推荐yyb dalao的总结——戳我 以后维护线段树还是把l,r写到struct里面吧，也别写len了，调试不好调qwq 初始化和叶节点初始化不太一样qwq，有的需要统一初始化的就一定注意不要写到if(l==r)里面qwq 求区间最大子段和 例题：codevs动态最大子段和 维护区间和...
算法刷题总结
qq_45818845的博客
03-25 1919
算法刷题总结 动态规划 提高课dp题解集合 提高课题单+题解(69/220) - AcWing 背包问题模板 题目链接 题意描述 题目总结 c++题解 python3题解 Java题解 自己的代码 [01背包问题](2. 01背包问题 - AcWing题库) 背包容量mmm​，物品数nnn,每个物品只能选一次， 第一层循环枚举所有物品，第二层循环倒着枚举体积 完全背包问题 背包容量mmm，物品数nnn,每个物品可以无限选 第一层循环枚举所有物品，由于不限制每个物品的数量第二层循环
2019春节培训
weixin_30819163的博客
02-01 92
\(Day1\) 今天讲了一些比较基础的一些可以说是优化暴力吧，因此是非常重要。 搜索 \(DFS\)和\(BFS\) \(dfs\)——深度优先搜索，用递归也就是栈实现，优点是代码实现简单，空间耗费少。缺点是不一定能很快的搜到最优解 \(bfs\)——宽度优先搜索，用对列实现，优点是第一个搜到的目标一定是最优解（狭义上的）。缺点是代码实现复杂，空间耗费大。 所以上面两种基本搜索需要按题来选择。 ...
倍增node
georgeyu-CJR的blog
07-27 116
倍增 普及组的内容，思想很简单，但是考的可以挺难 倍增是啥东西 “ 倍增，顾名思义，就是每次增加一倍。 展开来说，就是每次根据已经得到的信息，将考虑的范围增加一倍， 从而加速操作。倍增思想有什么用呢？这是一种非常巧妙的思想，可以用来解决信息学竞赛中的很多问题。 考虑这样一个比较一般的模型，在一个有向图中，每个点最多只有 一条出边，每条边有一定的信息，走过一条路径时，就将路径上边的信息依次按一定的规则合并，并且合并的规则满足结合律。” 普通的线性倍增 问题：给定数组aaa和数字TTT,求最大的位置kkk,
树上倍增_黄哲威.pdf
09-14
树上倍增算法是一种常用的算法，用于解决树上最近公共祖先（LCA）问题。在这篇文章中，我们将详细介绍树上倍增算法的原理、实现和应用。 1. 什么是树上倍增算法？ 树上倍增算法是一种用于解决树上最近公共祖先问题...
树链剖分模板题
05-19
int lca(int x,int y){ if(dep[x]>dep[y])up(x,dep[y]); if(dep[x][y])up(y,dep[x]); if(x==y)return x; for(int i=15;i>=0;--i) if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i]; return f[x][0]; } int getm(int ...
倍增法介绍以及应用（RMQ、LCA）
02-08
倍增法介绍以及应用（RMQ、LCA） 倍增法是一种常用的算法思想，广泛应用于解决范围查询、最近公共祖先等问题。下面，我们将详细介绍倍增法的定义、应用以及优化方法。 倍增法定义 ---------- 倍增法是指每个数是...
图论常见算法总结——prim,kruskal,dijkstra,floyed,bellman-ford,spfa
Se_ren_di_pity的博客
06-11 977
我们对到达结点u的最短路径所经历过的结点数cnt进行统计，显然cnt[u]不会超过n，若超过了n，说明已形成环路，且一定是负环。我们先建立一层外层循环，在每一次循环中，都枚举图中的m条边，并对起点到每一个结点的最短路径进行松弛更新，可以保证，每次最少更新一条边，那么在至多n-1次循环后，在循环中将不会再有边更新。任意选取一个起点u，设已加入树的结点为V，总结点为T，则每次搜索连接V与T-V的最短边，并使之加入V（即从T-V向V中加入一个新的节点），当T中所有节点访问完成，即为最小生成树。
图论之岛屿系列
frighting_ing的博客
06-18 266
形成模板进行学习，加快学习效率。
算法训练营第六十天（延长12天添加图论) | LeetCode 647 回文子串、LeetCode 516 最长回文子序列
qq_63149342的博客
06-15 320
如果相等就都放入，并且dp[i][j]等于dp[i+1][j-1]+2，否则dp[i][j]取dp[i+1][j]、dp[i][j-1]、dp[i][j]中最大值即可。这就是这道题的递推逻辑了。原本是从前往后循环内从后往前统计回文字符串数目，这题是从中间往两边，看两边分别接触到的第一个字符是否相等。思路很简单，每一个dp[i]等于dp[i-1]加上当前字符向前直到0各个长度字符串回文串个数即可。初始化方式是在i==j时要初始化为1。或者将dp[i][i]初始化为1也行。这题要在上一题基础上稍微转换下思路。
洛谷 B3609 [图论与代数结构 701] 强连通分量 题解 tarjan算法
一只摸鱼的bbc
06-11 1091
图论 强连通分量 tarjan算法 洛谷题解 C++代码 附详细注释
Linux基础 - 环境变量.mp4
06-18
Linux基础 - 环境变量.mp4大厂内部培训资料，都是干货！
模拟退火巡检顺序判定 使用MATLAB实现的机器人导航模拟退火巡检顺序判定，课运行.zip
06-18
模拟退火巡检顺序判定 使用MATLAB实现的机器人导航模拟退火巡检顺序判定，课运行
mcuisp串口下载软件
最新发布
06-18
mcuisp串口下载软件
Java文本编辑器应用程序（含源码）+GUI界面+使用说明+可做毕设
06-18
项目简介 JavaFX文本编辑器应用程序是一个简单的类似记事本的应用程序。在这个应用程序中，您可以轻松创建文本文档。该系统在编辑文本文件或文档时为您提供了更大的灵活性。该系统内置了各种功能，提供了编辑和样式化文本的控制。 系统简介 顾名思义，该项目主要用于编辑和创建文本文档。该项目增加了许多新功能，例如选择字体和字体粗细，以及字体样式（如加粗、斜体或下划线）。不仅如此，您还可以使用颜色格式突出显示文本，或者直接选择文本并为其着色。您还可以进行单词搜索，这有助于控制段落中的拼写错误。您还可以使用菜单栏中的注释符号引用您喜欢的句子。 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
基于UVM的中断处理UVC
06-18
用于处理中断信息，作为uvc可以在env中进行instance。操作简单，使用灵活
请为我解释图论在二叉树中的应用
06-12
图论在二叉树中有许多应用。下面列举几个例子： 1. 二叉树的遍历：二叉树的遍历可以看作是对二叉树节点的一种访问顺序。其中，前序遍历、中序遍历和后序遍历是最为常见的三种遍历方式。可以将二叉树看作是一种特殊...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值