LCT入门（动态树）（点权）（边权）

最新推荐文章于 2022-04-16 19:57:27 发布
最新推荐文章于 2022-04-16 19:57:27 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： 算法二
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1_s2_c3_/article/details/101199124
版权

LCT的用途：
1，在线链接link&cut（连接边，删除边）
2，查询连通性
3，维护链上信息
4，换根
5，维护子树信息。
等等：

基础知识：
1.伸展树（Splay Tree）
：支持链上求和，求最值，修改，等等操作，
2LCT（link cut tree）：是一棵树，长这样：

在这里插入图片描述
这上面有一些粗一点的边，我们把它称为重边；还有一些细一点的，我们把它称为轻边。

基本函数功能介绍：

access（x）：x-根节点变成重边，专门用一棵splay维护
makeroot(x):将x变成整棵LCT树的根。
link(x, y):新建一条边，x-y链接起来；
cut(x,y):删除边x-y;
split(x,y):将x-y路径取出分离。求解u到v的路径上的节点权值和只需split(u,v)，然后输出sum[v]即可。

rotate(x)/reverse(x):翻转x的子树：

下面来举一个直接套用模板的例子：
在这里插入图片描述
//在上面的代码中除了update（），pushdown()其他的都是模板。

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>

using namespace std;

inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}

const int maxn = 1e6+1e2;

int fa[maxn],ch[maxn][3]; //ch[i][0] -- 代表左孩子，ch[i][1]--代表右孩子； 
int rev[maxn],sum[maxn];    //sum[i]--表示i到根节点的异或和； 
int n,m;
int val[maxn];      //val--代表每一个点的权值。 
int st[maxn];

int son(int x)
{
	if (ch[fa[x]][0]==x) 
	  return 0;
	else return 1;
}

bool notroot(int x)
{
	return (ch[fa[x]][0]==x) || (ch[fa[x]][1]==x);
}

void update(int x)    //这是自己写的，在这个代码中是计算路径权值异或和，配合pushdown（）函数。 
{
	sum[x]=sum[ch[x][0]]^sum[ch[x][1]]^val[x];
}

void reverse(int x)
{
	swap(ch[x][0],ch[x][1]);
	rev[x]^=1;
}
void pushdown(int x)//里面的内容也是自己编辑的。
{
	if (rev[x])
	{
		if (ch[x][0]) reverse(ch[x][0]);
		if (ch[x][1]) reverse(ch[x][1]);
		rev[x]=0;
	}
}

void rotate(int x)
{
	int y=fa[x],z=fa[y];
	int b=son(x),c=son(y);
	if(notroot(y)) ch[z][c]=x;
    fa[x]=z;
	ch[y][b]=ch[x][!b];
	fa[ch[x][!b]]=y;
	ch[x][!b]=y;
	fa[y]=x;
	update(y);
	update(x);
	//cout<<1<<endl;
}

void splay(int x)
{
	int y=x,cnt=0;
	st[++cnt]=y;
	while(notroot(y)){y=fa[y];st[++cnt]=y;}
	while (cnt) pushdown(st[cnt--]);
	while (notroot(x))
	{
		int y=fa[x],z=fa[y];
		int b=son(x),c=son(y);
		if (!notroot(y)) rotate(x);
		else
		//if (notroot(y))
		{
			if (b==c)
			{
				rotate(y);
				rotate(x);
			}
			else
			{
				rotate(x);
				rotate(x);
			}
		}
		//cout<<1<<endl;
	 } 
	 update(x);
}

void access(int x)
{
	for (int y=0;x;y=x,x=fa[x])
	{
		splay(x);
		ch[x][1]=y;
		update(x); 
	}
}

void makeroot(int x)
{
	access(x);
	//splay(x);
	reverse(x);
} 

int findroot(int x)
{
   access(x);
   splay(x);
   while (ch[x][0])
   {
   	  pushdown(x);
   	  x=ch[x][0];
   }
   //splay(x);
   return x;
}

void split(int x,int y)
{
	makeroot(x);
	access(y);
	splay(y);
}

void link(int x,int y)
{
	makeroot(x);
	if (findroot(y)!=x) fa[x]=y;
}

void cut(int x,int y)
{
	split(x,y);
	if (ch[x][0] || ch[x][1] ||fa[x]!=y || ch[y][son(x)^1]) return;
	fa[x]=ch[y][0]=0;
}
//在上面的代码中除了update（），pushdown()其他的都是模板。
int main()
{
   n=read(),m=read();
   for (int i=1;i<=n;i++) val[i]=read();
   for (int i=1;i<=m;i++)
   {
      int opt=read(),x=read(),y=read();
      if(opt==0)  //为0 是计算x-y路径权值异或和。
      {
      	 split(x,y);  //提取这条路径
      	 printf("%d\n",sum[y]);
	  }
	  if(opt==1)//链接两条边
	  {
	  	 link(x,y); 
	  }            //切断两条边
	  if (opt==2)
	  {
	  	cut(x,y);
	  }
	  if (opt==3)
	  {
	  	 splay(x);     //把x转上去再改，不然会影响Splay信息的正确性
	  	 val[x]=y;
	  }
   }
   return 0;
}

第二个例子
在这里插入图片描述

第二个例子在一个例子基础上有所变化：

==求有多少条边经过x-y这一条边； 等于：这条边连接的两棵子树大小的乘积 ==
这个中就用不到权值。

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<map>
#include<set>

using namespace std;

inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}

const int maxn = 1e6+1e2;

int fa[maxn],ch[maxn][3]; //ch[i][0] -- 代表左孩子，ch[i][1]--代表右孩子； 
int rev[maxn],sum[maxn];    //sum[i]--表示i到根节点的异或和； 
int n,m;
int sz[maxn], lit[maxn];    //sz--代表节点子节点个数，lit--代表虚节点个数。 
int val[maxn];      //val--代表每一个点的权值。 
int st[maxn];

int son(int x)
{
	if (ch[fa[x]][0]==x) 
	  return 0;
	else return 1;
}

bool notroot(int x)
{
	return (ch[fa[x]][0]==x) || (ch[fa[x]][1]==x);
}

void update(int x)    //在这个函数中计算每一个点 
{
	//sum[x]=sum[ch[x][0]]^sum[ch[x][1]]^val[x];
	sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1 + lit[x];
}

void reverse(int x)
{
	swap(ch[x][0],ch[x][1]);
	rev[x]^=1;
}
void pushdown(int x)
{
	if (rev[x])
	{
		if (ch[x][0]) reverse(ch[x][0]);
		if (ch[x][1]) reverse(ch[x][1]);
		rev[x]=0;
//		if(rev[x])
//		{
//			rev[ch[x][1]] ^= 1;
//			rev[ch[x][0]] ^= 1;
//			rev[x]  = 0;
//			//rev
//			swap[]
//		}
	}
}

void rotate(int x)
{
	int y=fa[x],z=fa[y];
	int b=son(x),c=son(y);
	if(notroot(y)) ch[z][c]=x;
    fa[x]=z;
	ch[y][b]=ch[x][!b];
	fa[ch[x][!b]]=y;
	ch[x][!b]=y;
	fa[y]=x;
	update(y);
	update(x);
	//cout<<1<<endl;
}

void splay(int x)
{
	int y=x,cnt=0;
	st[++cnt]=y;
	while(notroot(y)){y=fa[y];st[++cnt]=y;}
	while (cnt) pushdown(st[cnt--]);
	while (notroot(x))
	{
		int y=fa[x],z=fa[y];
		int b=son(x),c=son(y);
		if (!notroot(y)) rotate(x);
		else
		//if (notroot(y))
		{
			if (b==c)
			{
				rotate(y);
				rotate(x);
			}
			else
			{
				rotate(x);
				rotate(x);
			}
		}
		//cout<<1<<endl;
	 } 
	 update(x);
}
 
void access(int x)    //修改过: 
{
	for (int y=0;x;y=x,x=fa[x])
	{
		splay(x);
		lit[x] += sz[ch[x][1]] - sz[y];  //这个地方； 
		ch[x][1]=y;
		update(x); 
	}
}

void makeroot(int x)
{
	access(x);
	splay(x);
	reverse(x);
} 

int findroot(int x)
{
   access(x);
   splay(x);
   while (ch[x][0])
   {
   	  pushdown(x);
   	  x=ch[x][0];
   }
   //splay(x);
   return x;
}

void split(int x,int y)
{
	makeroot(x);
	access(y);
	splay(y);
}

void link(int x,int y)//修改过：
{
	makeroot(x);
	//if (findroot(y)!=x) fa[x]=y;
	access(y);
	splay(y);
	fa[x] = y;
	lit[y] += sz[x];
	update(y);
}

void cut(int x,int y)
{
	split(x,y);
	if (ch[x][0] || ch[x][1] ||fa[x]!=y || ch[y][son(x)^1]) return;
	fa[x]=ch[y][0]=0;
}

int main()
{
   //n=read(),m=read();
   scanf("%d%d", &n, &m);
   for (int i=1;i<=n;i++) sz[i] = 1;//val[i]=read();
   for (int i=1;i<=m;i++)
   {
   	  char s[10];
   	  int x, y;
      scanf("%s",s);
	  scanf("%d%d",&x,&y);
      if(s[0] == 'Q')
      {
      	makeroot(x);
      	access(y);
      	splay(y);
      	printf("%d\n", sz[x]*(sz[y]-sz[x]));
	  }
	  else
	  {
	  	link(x, y);
	  }
   }
   return 0;
}

上面的两个例子是关于点权的，经过某一条边的，下面这个例子是边权的。

题意：
给定一个边权树，要求支持动态修改边权，询问到某个点最远的点的距离

题目来源：

代码这个算法还不了解，以后补；
代码：

#include <set>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;

typedef long long ll;

int read() {
	char ch;
	for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
	int x=ch-'0';
	for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x;
}

void write(ll x) {
	if (!x) {puts("0");return;}
	char ch[20];int tot=0;
	for(;x;x/=10) ch[++tot]=x%10+'0';
	fd(i,tot,1) putchar(ch[i]);
	puts("");
}

const int N=2e5+5;
const ll inf=1e16;

struct Path{
	int u,v;ll w;
	Path(){}
	Path(int u,int v,ll w):
		u(u),v(v),w(w){}
	Path operator + (const ll x)const{return Path(u,v,w+x);}
	Path operator - (const ll x)const{return Path(u,v,w-x);}
	Path operator + (const Path& x)const{
		Path ret;
		ret.u=u;ret.v=x.u;
		if (ret.u<ret.v) swap(ret.u,ret.v);
		ret.w=w+x.w;
		return ret;
	}
	bool operator < (const Path& x)const{
		if (w!=x.w) return w<x.w;
		if (u!=x.u) return u<x.u;
		return v<x.v;
	}
};

struct Data{
	Path pre,suf,ans;ll sum;
	Data(){}
	Data(Path pre,Path suf,Path ans,ll sum):
		pre(pre),suf(suf),ans(ans),sum(sum){}
	Data operator + (const Data& x)const{
		Data ret;
		ret.pre=max(pre,x.pre+sum);
		ret.suf=max(suf+x.sum,x.suf);
		ret.ans=max(ans,x.ans);
		ret.ans=max(ret.ans,suf+x.pre);
		ret.sum=sum+x.sum;
		return ret;
	}
};

namespace LCT{
	int f[N],t[N][2],p[N],sta[N],top;
	multiset<Path> pre[N],ans[N];
	ll val[N];
	Data a[N],ra[N],dp[N];
	bool rev[N];

	void upd(int x) {
		int ls=t[x][0],rs=t[x][1];
		a[x]=ra[x]=Data(dp[x].pre+val[x],dp[x].pre+val[x],dp[x].ans,val[x]);
		if (ls) {
			a[x]=a[ls]+a[x];
			ra[x]=ra[x]+ra[ls];
		}
		if (rs) {
			a[x]=a[x]+a[rs];
			ra[x]=ra[rs]+ra[x];
		}
	}

	int son(int x) {return t[f[x]][1]==x;}

	void rotate(int x) {
		int y=f[x],z=son(x);
		if (f[y]) t[f[y]][son(y)]=x;
		else p[x]=p[y],p[y]=0;
		if (t[x][1-z]) f[t[x][1-z]]=y;
		t[y][z]=t[x][1-z];t[x][1-z]=y;
		f[x]=f[y];f[y]=x;
		upd(y);upd(x);
	}

	void reverse(int x) {
		if (!x) return;
		swap(t[x][0],t[x][1]);
		swap(a[x],ra[x]);
		rev[x]^=1;
	}

	void down(int x) {
		if (rev[x]) {
			reverse(t[x][0]);reverse(t[x][1]);
			rev[x]=0;
		}
	}

	void remove(int x,int y) {
		do {sta[++top]=x;x=f[x];} while (x!=y);
		for(;top;down(sta[top--]));
	}

	void splay(int x,int y) {
		remove(x,y);
		while (f[x]!=y) {
			if (f[f[x]]!=y) 
				if (son(x)==son(f[x])) rotate(f[x]);
				else rotate(x);
			rotate(x);
		}
	}

	void get(int x) {
		dp[x].pre=*pre[x].rbegin();
		dp[x].ans=*ans[x].rbegin();
		if (pre[x].size()>=2) {
			auto smx=pre[x].rbegin(),mx=smx;smx++;
			dp[x].ans=max(dp[x].ans,*smx+*mx+val[x]);
		}
	}

	void add(int x,int y) {
		pre[x].insert(a[y].pre);
		ans[x].insert(a[y].ans);
		get(x);
	}

	void del(int x,int y) {
		pre[x].erase(pre[x].find(a[y].pre));
		ans[x].erase(ans[x].find(a[y].ans));
		get(x);
	}

	void access(int x) {
		int y=0;
		for(;x;y=x,x=p[x]) {
			splay(x,0);
			if (t[x][1]) {
				add(x,t[x][1]);
				f[t[x][1]]=0;p[t[x][1]]=x;
			}
			if (y) {
				del(x,y);
				f[y]=x;p[y]=0;
			}
			t[x][1]=y;
			upd(x);
		}
	}

	void make_root(int x) {access(x);splay(x,0);reverse(x);}

	void link(int u,int v) {
		make_root(u);make_root(v);
		p[v]=u;add(u,v);upd(u);
	}

	bool check(int u,int v) {
		make_root(u);access(v);
		splay(v,0);
		for(;u&&u!=v;u=f[u]);
		return u==v;
	}
}

int n;
char opt[5];

int main() {
	n=read();
	fo(i,1,n) {
		LCT::pre[i].insert(Path(i,i,0));
		LCT::ans[i].insert(Path(i,i,0));
		LCT::get(i);LCT::upd(i);
	}
	fo(i,1,n-1) {
		int x=read(),y=read(),z=read(),v=i+n;
		LCT::val[v]=z;
		LCT::pre[v].insert(Path(0,0,-inf));
		LCT::ans[v].insert(Path(0,0,-inf));
		LCT::get(v);LCT::upd(v);
		if (LCT::check(x,y)) continue;
		LCT::link(x,v);LCT::link(v,y);
	}
	for(int q=read();q;q--) {
		scanf("%s",opt);
		if (opt[0]=='C') {
			int x=read()+n,y=read();
			LCT::make_root(x);LCT::access(x);
			LCT::val[x]=y;LCT::get(x);LCT::upd(x);
		}
		if (opt[0]=='Q') {
			int x=read();
			LCT::make_root(x);
			write(LCT::a[x].pre.w);
		}
	}
	return 0;
}
一扁舟
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
边与边权1
08-08
一开始棋子位于起始节点，每条边上的权值非负，Alice和Bob轮流操作，每次可以向与棋子有一条正权边直接相连的节点移动，移动后该边权值减少至一个非负整数，减少量
复杂网络networkx点权和边权添加提取
weixin_47710774的博客
06-08 1845
import networkx as nx G = nx.Graph() G.add_nodes_from([("01", {'size': 100}), ("02", {'size': 200}), ("03", {'size': 300})]) #G.add_edges_from([('01','02',{'weight':0.8}), ('02','03',{'weight':0.9}), ('01','03',{'weight':0.5})]) G.add_weighted_edges_fro.
「APIO2010」巡逻 题解
lefy959的博客
04-16 459
来源 LCA 个人评价：lca求路径，让我发现了自己不会算树的直径（但是本人似乎没有用lca求） 1 题面 「APIO2010」巡逻 大意：有一个有n个节点的树，每条边权为1，一每天要从1号点开始，遍历所有的边，再回到1号点，每条道路都经过两次，为了减少需要走的距离，可以增加K(1≤K≤2)(1\leq K\leq 2)(1≤K≤2)条新的边（可以自环），且每天必须经过这K条边正好一次，请计算最佳方案是总路程最小，并输出最小值 2 分析题面 因为K很小，所以我们可以试着手推一下每种情况 2.1 不加边 .
最短路算法分析
蒟蒻wxn的博客
05-13 354
最短路算法分析 如下图所示，我们把边带有权值的图称为带权图。边的权值可以理解为两点之间的距离。一张图中任意两点间会有不同的路径相连。最短路就是指连接两点的这些路径中最短的一条。 对于所有求最短路的算法，都是基于一个最基础的思想，那就是：松弛。 什么叫松弛呢？简单的说，就是刷新最短路。 那，怎么刷新呢？我们想，能刷新最短路的有啥？就是用最短路（边也可能是最短路）。要用魔法打败魔法 以下图为例，...
算法之图论(二)有权最短路
释怀°Believe的博客
03-25 964
文章目录一、Floyd算法（多源）二、Dijkstra算法（单源） 有权图：我们把带有权值的称为有权图。 边权：可以理解为两点之间的距离或费用。 最短路径： 从源点到终点之间的所有路径中，边权之和最小的那一条路径，称为这两点之间的最短路径。 （1）多源最短路径问题：求任意两点之间的最短路径。Floyd算法 （2）单源最短路径问题：从某固定源点出发，求其到所有其他顶点的最短路径。 常用有Dijkstra算法，Ford算法，SPFA算法。 一、Floyd算法（多源） 需要利用邻接矩阵存储图, 例如,对于上图
最小生成树设G=（V，E）是无向图联通带权图，即一个网络。E中每条边（v，w）的权为c[v][w]。如果G的一个子图G’是一棵包含G的所有定点的树，则称G’为G的生成树。生成树上各边权的总和称为该生成树的耗费。在G的所有生成树中，耗费最小的生成树称为最小生成树。采用贪心策略可以直接求得给定网络的最小生成树。
03-11
设G=（V，E）是无向图联通带权图，即一个网络。E中每条边（v，w）的权为c[v][w]。如果G的一个子图G’是一棵包含G的所有定点的树，则称G’为G的生成树。生成树上各边权的总和称为该生成树的耗费。在G的所有生成树中，耗费最小的生成树称为最小生成树。采用贪心策略可以直接求得给定网络的最小生成树。 解析请参加教材115页。 实验方法： 使用贪婪法设计本问题的解决方案。 编成任务： 给定网络图，求其最小生成树。 Input 节点个数和给定网络图的邻接矩阵表示方法，其中权值为65535表示两个节点间没有连接。否则数字表示节点间权值。 Output 输出最小生成树包括的节点 Sample Input 11 65535 9 59 69 96 11 72 100 17 43 28 9 65535 40 21 23 61 78 97 41 76 86 59 40 65535 39 48 55 64 11 85 23 44 69 21 39 65535 82 80 62 80 98 8 78 96 23 48 82 65535 70 97 55 2 6 2 11 61 55 80 70 65535 45 71 45 42 45 72 78 64 62 97 45 65535 72 93 89 17 100 97 11 80 55 71 72 65535 97 28 100 17 41 85 98 2 45 93 97 65535 70 77 43 76 23 8 6 42 89 28 70 65535 72 28 86 44 78 2 45 17 100 77 72 65535 Sample Output 106
LCT维护子树信息（子树信息LCT） LCT维护边权（边权LCT） 知识点讲解
neither_nor
10-31 9264
扯淡（前言） 众所周知LCT可以支持关于点权的链修改，换根，LINK，CUT和查询链信息操作，但是总有那么些神犇（毒瘤）出题人会让你在支持链修改，换根，LINK和CUT操作的情况下去支持子树查询，或者维护关于边权的链修改，换根，LINK，CUT和链查询。网上似乎讲解这两种LCT写法的blog比较少或者不怎么能搜到？总之我来写一发 （LCT基础知识回顾） 为了方便说话先说一下下面可能出现的
树链剖分（边权）
gebixiaofang的博客
10-22 361
#include&lt;bits/stdc++.h&gt; #define MAX 123466 #define ll long long using namespace std; struct Front_Link_Star{ int next,to; }edge[MAX&lt;&lt;1]; ll Ma,Mi; ll tree[MAX &lt;&lt; 2],lazy[MAX &l...
【树链剖分】【点权】
Vampire
05-20 1216
1036: [ZJOI2008]树的统计CountTime Limit: 10 Sec Memory Limit: 162 MB Submit: 7568 Solved: 3109 [Submit][Status][Discuss] Description一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u
PAT A1111 2019.09.07 【dijkstra dfs 边权/点权】
一个非计算机专业的 博客
09-07 268
1111Online Map(30分) Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other...
动态树LCT BySemiWaker
03-05
动态树LCT
lct.zip_LCT
09-19
2222我而无法说服 去取钱完全 完全
lct_LCT_
09-29
一个高级的动态树实现实例，用于了解熟悉算法。
lct.zip_lct文件
09-24
很实用的库文件，可以方便使用里面的现成库文件。
动态树课件
03-26
2019-2020 ICPC Asia Yinchuan Regional Contest【银川现场赛】
qq_2992427261
03-17 1258
A. Girls Band Party 题目链接 Description You are currently playing a game called “Garupa”. In an event of the game, you are trying to get more event points. You have nn cards, each with its own name, colo...
固定长度的路径数
qq_2992427261
09-24 936
固定长度的路径数 我们有一个有向的，未加权的图G，有n个顶点，我们有一个整数k，任务如下:对于每一对顶点(i,j)，我们必须找到这些顶点之间长度为k的路径的数量。路径不必简单，也就是说，顶点和边可以在一条路径中访问任意次数。 分析： 我们假设图是用邻接矩阵指定的，即大小为n×n的矩阵G[][]，其中，如果顶点i与j通过一条边相连，则每个元素G[i][j]都等于1,0为它们不通过一条边相连。下面的算...
半平面交
qq_2992427261
09-26 879
什么是半平面：半平面就是指平面的一半，我们知道，一条直线可以将平面分为两个部分，那么这两个部分就叫做两个半平面。 半平面怎么表示呢： 二维坐标系下，直线可以表示为ax + by + c = 0，那么两个半平面则可以表示为ax + by + c >= 0 和ax + by + c < 0，这就是半平面的表示方法。 半平面的交： 其实就是一个方程组，让你画出满足若干个式子的坐标系上的区域（...
lct动态维护最小生成树
最新发布
08-05
要动态维护最小生成树，可以使用以下算法： 1. 初始化：开始时，将最小生成树设置为一个空集合。 2. 添加边：当有新的边添加到图中时，检查该边是否会形成环路。如果形成环路，则舍弃该边；否则，将该边加入最小生成树。 3. 删除边：当一条边被删除时，检查最小生成树是否仍然连通。如果不连通，则需要找到一条新的边来连接两个不连通的部分，使得最小生成树仍然有效。 4. 更新权重：当一条边的权重发生变化时，需要重新计算最小生成树。可以使用Kruskal或Prim算法来重新构建最小生成树。 这些步骤可以在实际应用中进行优化，例如使用并查集来判断是否形成环路，使用堆来快速找到新的边等。通过动态维护最小生成树，可以在图的结构发生变化时快速更新最小生成树，以保持其有效性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值