最短路，生成树和生成树形图相关

最新推荐文章于 2022-04-19 15:16:33 发布
最新推荐文章于 2022-04-19 15:16:33 发布
阅读量298 收藏
点赞数
分类专栏： 图论相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43973966/article/details/85338036
版权

  • 存图相关

-1.邻接表：

          \ \ \ \ \ \ \ \,        在点数特别小的时候，我们可以用邻接表（二维数组）来表示点之间的链接关系。

int e[N][N];
void add(int a,int b,int w){e[a][b]=w;}

-2. 链表：

          \ \ \ \ \ \ \ \,        在点数比较大的时候，我们可以用链式向前星来表示点之间的链接关系。

int head[N],p;
struct Edge{int v,w,last;}E[N];
void add(int a,int b,int w)
{E[++p]=(Edge){b,w,head[a]};head[a]=p;}

          \ \ \ \ \ \ \ \,        遍历方式如下：

for(int i=head[u];i;i=G[i].last)G[i].v,G[i].w;
//G[i].v就是u的直接连接点，G[i].w是边上信息

-3.动态数组

          \ \ \ \ \ \ \ \,        在点数比较大的时候，我们可以用 v e c t o r \tt vector vector，会比链表慢一点，但是比较方便，下面默认都是这种存图方法。

struct Edge{int p,w;}E[N];
vector<Edge> e[N];
void add(int a,int b,int w)
{e[a].push_back((Edge){b,w});}

       &ThinSpace; \ \ \ \ \ \ \,       遍历方式如下：

for(auto v:E[u])v.p,v.w;
//v.p就是u的直接连接点，v.w是边上信息

  • 最短路

        &ThinSpace; \ \ \ \ \ \ \ \,        最短路的核心思想都差不多，用松弛操作来求解，所以只讲算法特点和用法，不讲原理：

-1.Floyd

        &ThinSpace; \ \ \ \ \ \ \ \,        Floyd可以在 O ( n 3 ) O(n^3) O(n3)的时间内，求出任意点对两两之间的距离，支持负边权：

int dis[N][N];
void floyd(){
	memset(dis,63,sizeof(dis));
	for(int i=1;i<=n;i++){
		dis[i][i]=0;
		for(auto v:E[i])dis[i][v.p]=v.w;
	}
	for(int k=1;k<=n;k++)
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	if(dist[i][j]>dist[i][k]+dist[k][j])
	dist[i][j]=dist[i][k]+dist[k][j];
}

-2.SPFA

        &ThinSpace; \ \ \ \ \ \ \ \,        SPFA可以在下到 n n n上到 ( n 2 ) (n^2) (n2)的时间内，求出单源对于每个点最短路，支持负边权，但是因为复杂度不平衡，关于SPFA,他死了：

int dis[N];
bool used[N];
queue<int> Q;
void SPFA(int S){
	memset(dis,63,sizeof(dis));
  Q.push(S);used[S]=1;dis[S]=0;
  while(!Q.empty()){
    int u=Q.front();Q.pop();used[u]=0;
    for(auto v:E[u])
    if(dis[v.p]>dis[u]+v.w){
      dis[v.p]=dis[u]+v.w;
      if(used[v.p]==0)
			{used[v.p]=1;Q.push(v.p);}
    }
  }
}

        &ThinSpace; \ \ \ \ \ \ \ \,        或者SPFA加上堆优化后，复杂度会比较好，长得也和Dijkstra很相像了：

struct node{int v,dis;};
inline bool operator <(const node &a,const node &b)
{return a.dis>b.dis;}
int dis[N];
priority_queue<node> Q;
void heap_SPFA(int S){
	memset(dis,63,sizeof(dis));
  Q.push((node){1,0});
	dis[S]=0;used[S]=1;
  while(!Q.empty()){
    int u=Q.top().v;Q.pop();used[u]=0;
    for(auto v:E[u])
    if(dis[v.p]>dis[u]+v.w){
      dis[v.p]=dis[u]+v.w;
      if(used[v.p]==0)
			{used[v.p]=1;Q.push((node){dis[v.p],v.p})};
    }
  }
}

-3.Dijkstra

        &ThinSpace; \ \ \ \ \ \ \ \,        Dijkstra可以在 O ( n log ⁡ n ) O(n\log n) O(nlogn)的时间内，求出单源对于每个点最短路，但是不支持负边权：

struct node{int v,dis;};
inline bool operator <(const node &a,const node &b)
{return a.dis>b.dis;}
int dis[N];
priority_queue<node> Q;
void Dijkstra(int S){
	memset(dis,63,sizeof(dis));
  	Q.push((node){1,0});dis[S]=0;
  	while(!Q.empty()){
    	int u=Q.top().v;Q.pop();
    	for(auto v:E[u])
    	if(dis[v.p]>dis[u]+v.w){
      		dis[v.p]=dis[u]+v.w;
			Q.push((node){dis[v.p],v.p});
    	}
  	}
}

  • 生成树

        &ThinSpace; \ \ \ \ \ \ \ \,        生成树是针对无向图的说法，基本上是基于贪心的操作。

-1.最小生成树

        &ThinSpace; \ \ \ \ \ \ \ \,        最小生成树最常见的贪心做法是Kruskal，因为一棵树 n − 1 n-1 n−1条边，我们可以把所有边排序过后，贪心选取能构成树的最小的 n − 1 n-1 n−1条边，用并查集维护其连通性：

int top,fa[N];
struct Link{int u,v,w;}e[N];
inline bool operator <(const Link &a,const Link &b){return a.w<b.w;}
int find(int a){return a==fa[a]?a:fa[a]=find(fa[a]);}
void add_edge(int a,int b,int w){e[++top]=(Link){a,b,w};}
void Kruskal(){
	sort(e+1,e+top+1);
	for(int i=1;i<=n;i++)fa[i]=i;
  for(int i=1,A,B;i<=m;i++)
  if((A=find(e[i].u))!=(B=find(e[i].v))){
		add(e[i].u,e[i].v,e[i].w);
		add(e[i].v,e[i].u,e[i].w);
		fa[A]=B;
	}
}

-2.次小生成树\k小生成树\严格次小生成树

        &ThinSpace; \ \ \ \ \ \ \ \,        次小生成树，我们就是做如下操作：

  1. 做一次最小生成树；

  2. 在没有加入树边的边中选一个最小的，假设为u与v之间的边；

  3. 在最小生成树上面 u u u到 v v v的路径上，删除一条最长的边；

  4. 然后把2步中选择的边加入树边。

        &ThinSpace; \ \ \ \ \ \ \ \,        复杂度是 O ( m log ⁡ m + n log ⁡ n ) O(m\log m+n\log n) O(mlogm+nlogn)，操作比较繁琐，虽然有些时候不需要真实建树，但是还是很繁琐，就不单独贴模板了。

        &ThinSpace; \ \ \ \ \ \ \ \,        对于k小生成树，我们做k次就好了啊，复杂度 O ( m log ⁡ m + k n log ⁡ n ) O(m\log m+kn\log n) O(mlogm+knlogn)。

        &ThinSpace; \ \ \ \ \ \ \ \,        对于严格次小生成树，我们做最多 m m m次，检查直到严格大于最小生成树就停止，复杂度 O ( m log ⁡ m + m n log ⁡ n ) O(m\log m+mn\log n) O(mlogm+mnlogn)。

        &ThinSpace; \ \ \ \ \ \ \ \,        代码很长，引起不适：

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<set>
using namespace std;
const long long inf=2147483647000000;
const double eps=1e-10;
const double pi=acos(-1.0);
//char buf[1<<15],*S=buf,*T=buf;
//char getch(){return S==T&&(T=(S=buf)+fread(buf,1,1<<15,stdin),S==T)?0:*S++;}
inline int read(){
	int x=0,f=1;char ch;ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-') f=0;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch&15);ch=getchar();}
	if(f)return x;else return -x;
}
const int N=900010;
int n,m;
long long Cnt;
bool used[N];
struct Edge{int p,w;}E[N];
vector<Edge> G[N<<1];
void add(int a,int b,int w)
{G[a].push_back((Edge){b,w});}
int top,Fa[N];
struct Link{int u,v,w;}e[N];
inline bool operator <(const Link &a,const Link &b){return a.w<b.w;}
int find(int a){return a==Fa[a]?a:Fa[a]=find(Fa[a]);}
void add_edge(int a,int b,int w){e[++top]=(Link){a,b,w};}
void Kruskal(){
	sort(e+1,e+top+1);
	for(int i=1;i<=n;i++)Fa[i]=i;
  for(int i=1,A,B;i<=m;i++)
  if((A=find(e[i].u))!=(B=find(e[i].v))){
		add(e[i].u,e[i].v,e[i].w);
		add(e[i].v,e[i].u,e[i].w);
		Cnt+=1ll*e[i].w;
		used[i]=1;
		Fa[A]=B;
	}
}

int fa[N][19],deep[N];
long long Max[N][19],Min[N][19];
void dfs(int u,int f){
  fa[u][0]=f;
  for(auto v:G[u]){
    if(v.p==f)continue;
    deep[v.p]=deep[u]+1;
    Max[v.p][0]=v.w;
    Min[v.p][0]=-inf;
    dfs(v.p,u);
  }
}
void cal(){
  for(int i=1;i<=18;++i)
  for(int j=1;j<=n;++j){
    fa[j][i]=fa[fa[j][i-1]][i-1];
    Max[j][i]=max(Max[j][i-1],Max[fa[j][i-1]][i-1]);
    Min[j][i]=max(Min[j][i-1],Min[fa[j][i-1]][i-1]);
    if(Max[j][i-1]>Max[fa[j][i-1]][i-1])
		Min[j][i]=max(Min[j][i],Max[fa[j][i-1]][i-1]);
    else if(Max[j][i-1]<Max[fa[j][i-1]][i-1])
		Min[j][i]=max(Min[j][i],Max[j][i-1]);
  }
}
int LCA(int x,int y){
  if(deep[x]<deep[y])swap(x,y);
  for(int i=18;i>=0;--i)
  if(deep[fa[x][i]]>=deep[y])x=fa[x][i];
  if(x==y)return x;
  for(int i=18;i>=0;--i)
  if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
  return fa[x][0];
}
long long qmax(int u,int v,long long maxx){
  long long Ans=-inf;
  for(int i=18;i>=0;--i)
  if(deep[fa[u][i]]>=deep[v]){
    if(maxx!=Max[u][i])Ans=max(Ans,Max[u][i]);
    else Ans=max(Ans,Min[u][i]);
    u=fa[u][i];
	}
  return Ans;
}
int main()
{
	n=read(),m=read();
	for(int i=1,a,b,c;i<=m;i++)
	a=read(),b=read(),c=read(),
	add_edge(a,b,c);
	Kruskal();
	long long Ans=inf;
  Min[1][0]=-inf;
  deep[1]=1;
	dfs(1,-1);cal();
	for(int i=1;i<=m;++i)if(!used[i]){
    int u=e[i].u,v=e[i].v,lca=LCA(u,v);
    long long d=e[i].w;
    Ans=min(Ans,Cnt-max(qmax(u,lca,d),qmax(v,lca,d))+d);
  }
  printf("%lld",Ans);
	return 0;
}

-3.斯坦纳树

        &ThinSpace; \ \ \ \ \ \ \ \,        当只要求图的一部分点连接的时候，求最小的生成树，就是斯坦纳树，做法比较繁琐，大数据也不能优秀地处理。具体看这里【斯坦纳树学习笔记(VictoryCzt Orz)】。

  • 生成树形图

        &ThinSpace; \ \ \ \ \ \ \ \,        树形图不是一个有很好求法的东西，朱刘算法可以做到复杂度 O ( n m ) O(nm) O(nm)求出最小树形图，过程大概如下：

  1. 找到除了 r o o t root root以为其他点的权值最小的入边，如果出现除了 r o o t root root以外存在其他孤立的点，则不存在最小树形图。

  2. 找到图中所有的环，并对环进行缩点，重新编号，更新其他点到环上的点的距离。

  3. 以环数为下一次查找的点数，继续执行上述操作，直到没有环或者判定出不存在最小树形图为止。

        &ThinSpace; \ \ \ \ \ \ \ \,        大概就是这个图的意思：

int n,root;  
int k[N],idx[N],x,tim;
int cost[N],fa[N],f[N];
int mincost[N],ans,top;
struct Link{int u,v,w;}e[N];
inline bool operator <(const Link &a,const Link &b){return a.w<b.w;}
void add_edge(int a,int b,int w){e[++top]=(Link){a,b,w};}
int Zhu_Liu(int root){
  while(1){
    memset(mincost,63,sizeof(mincost));
    memset(idx,-1,sizeof(idx));
    memset(f,0,sizeof(f));
    for(int i=1;i<=m;i++)
    if(e[i].w<mincost[e[i].v]&&e[i].u!=e[i].v)
		{mincost[e[i].v]=e[i].w;fa[e[i].v]=e[i].u;}
    mincost[root]=0;tim=0;
    for(int i=1;i<=n;i++){
    	if(mincost[i]==mincost[0])return -1;
      ans+=mincost[i];x=i;
      while(f[x]!=i&&x!=root)f[x]=i,x=fa[x];
      if(x!=root&&idx[x]==-1){
        tim++;
        for(int j=fa[x];j!=x;j=fa[j])idx[j]=tim;
        idx[x]=tim;
      }
    }
    if(tim==0)break;
    for(int i=1;i<=n;i++)
    if(idx[i]==-1)idx[i]=++tim;
    for(int i=1;i<=m;i++){
      x=e[i].v;e[i].u=idx[e[i].u];e[i].v=idx[e[i].v];
      if(e[i].u!=e[i].v)e[i].w-=mincost[x];
    }
    n=tim;root=idx[root];
  }
  return ans;
}

  • 生成树和生成树形图计数

        &ThinSpace; \ \ \ \ \ \ \ \,        计数的话，需要用到矩阵树定理：

        &ThinSpace; \ \ \ \ \ \ \ \,        图基尔霍夫矩阵的行列式值就是图的生成树个数

        &ThinSpace; \ \ \ \ \ \ \ \,        对于生成树形图同样适用，把双向边和入度改为单向即可，通过线性代数技巧优化求行列式的复杂度，可以做到 O ( n 3 + n m ) O(n^3+nm) O(n3+nm)。

int A[N][N];
void add(int a,int b){
	A[a][a]++;A[b][b]++;
	A[a][b]--;A[b][a]--;
}
int Gauss(){
	int ans=1;
	for(int i=1;i<n;i++){
		for(int j=i+1;j<n;j++)
		while(A[j][i]){
			int t=A[i][i]/A[j][i];
			for(int k=i;k<n;k++)
			A[i][k]-=t*A[j][k];
			swap(A[j],A[i]);
			ans=-ans;
		}
		ans*=A[i][i];
	}
	return ans
}
周道-Althen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树(Prim、Kruskal)算法，秒懂！
bigsai
09-30 4万+
前言 在数据结构与算法的图论中，(生成)最小生成树算法是一种常用并且和生活贴切比较近的一种算法。但是可能很多人对概念不是很清楚，什么是最小生成树? 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 通俗易懂的讲就是最小生成树包含原图的所有节点而只用最少的边和最小的权值距离。因为n个节点最少需要n-1个边联通，而距离就需要采取某种策略选择恰当的边。 学习最
leetcode中国-leetcode_algo:leetcode相关算法和模板使用python
06-29
最小生成树 二分图：染色法、匈牙利算法 数学知识 —— 代码模板链接 常用代码模板4——数学知识 质数 约数 欧拉函数 快速幂 扩展欧几里得算法 中国剩余定理 高斯消元 组合计数 容斥原理 简单博弈论 动态规划 背包...
最小生成树
热门推荐
ZhuRanCheng的博客
08-18 2万+
最小生成树总结
【图解算法】最小生成树
就爱摆烂
04-19 7910
最小生成树 Prim Kruskal...
最小生成树入门（图解）
只会简单的代码的博客
03-28 7324
1.什么是最小生成树 来看百度百科的定义 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n个结点，并且有保持图连通的最少的边。最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 意思简单明了就是求最小的连通图 举个栗子 这幅图的极小连通图为 或者 就是从一个点能到达图的任意一点，且花费的代价最小（所有边的权值最小） 2.普里姆（Prim）算法 此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s
leetcode递归专题-leetcode:不定期发布leetcode解题思路和代码
06-30
树形DP 树 二叉树 前缀树 -- 其他树上问题 ---- ---- ---- ---- ---- ---- ---- ---- ---- 图 拓扑排序 最小生成树 最短路 联通分量 二分图 网络流 搜索 暴力搜索 DFS BFS 数组 其他算法/数据结构 位运算 并查集 二...
ACM算法模板和pku代码
11-09
最小树形图 无向图全局最小割 stoer-wagner O(n^3) 最短路径优先算法 SPFA 网络流 最大流：Ford&Fulkerson算法 最大流：Dinic算法 最大流：ek算法 最大流：dsp算法 最大流：hlpp算法 最小费用最大流：...
acm-template:acm-icpc的一些模板
06-04
最小树形图 朱刘算法 最大密度子图 01分数规划 && 网络流 无向图全局最小割 度数限制的最小生成树 最小直径生成树 最优比率生成树 最小环 k短路 网络流 最大流 Dinic SAP 最小费用最大流(spfa增广，zkw费用流) spfa ...
ACM图论数据结构常见模板
09-26
最小树形图 20 拓扑排序 22 最大团 23 LCA 24 倍增 24 基于RMQ（ST表） 26 Tarjan 28 二分图 31 相关总结 31 二分图最大匹配 32 二分图最大权匹配 35 网络流 38 最大流 && 最小割 38 费用流 46 一般数据结构 49 ST ...
基于最大生成树的股票相关性演化研究
03-20
在本研究中，我们选择标准普尔500指数成分股268只，伦敦证券交易所221只股票，上证综合指数148只成分股和恒生指数152只成分股的每日收盘价作为研究对象，并选择从2003年1月2日到2013年9月16日的所有股票样本。对于每个股票市场，首先，我们使用移动窗口浏览每个股票收益系列，并使用相互信息来衡量股票收益之间的统计相互依赖性，在每个给定的窗口中构造一个相应的加权网络。然后，通过分析从每个加权网络中提取的最大生成树的平均互信息，互信息分布和拓扑结构的变化，研究股票相关性的演变。所有获得的结果表明，对于所有股票市场，平均相互信息和相互信息分布的标准偏差都首先逐渐增加，并在整个爆发期达到峰值，最后又减少。另外，最大生成树的拓扑结构也先从紧凑的星形变为松散的链状，然后又再次变为紧凑的星形。所有事实告诉我们，危机确实改变了股票相关性，并且股票相关性先从弱变强，然后又变弱。
求最小费用或最短路径（最小生成树）
11-21
求最小费用或最短路径（最小生成树） 网络建设问题，旅行路径问题等等
ZOJ - 3195 Design the city （树上多点间最短路径）
柳予欣的三味书屋~
04-24 431
Cerror is the mayor of city HangZhou. As you may know, the traffic system of this city is so terrible, that there are traffic jams everywhere. Now, Cerror finds out that the main reason of them is the...
算法与数据结构|最小生成树（最小支撑树）
weixin_34014555的博客
01-29 397
概念：设G=（V，E）是一个无向连通图，生成树上各边的权值之和为该生成树的代价，在G的所有生成树中，代价最小的生成树就称为最小支撑树，或称最小生成树。 区别：最小生成树是各边权值和最小的数 　　　最优归并树是带权外部路径长度最短的树 算法：Kruskal算法 && Prim算法 代码来自 http://blog.csdn.net/luoshixian099/article/...
求各点间最短路算法（树形）
huantwofat
05-16 1726
由于floyd算法为O(n^3)算法，肯定会超时
2023年加湿器市场分析.pptx
最新发布
04-18
行业分析报告
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage
04-18
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage 支持Unity版本2019.4.29或更高 直接的低多边形骨架。 特点： - 低多边形（9k tris，8.5） - 适用于 Unity 5 及更高 版本 - 完全装配 - 包括一个 fbx 格式的模型 - PBR 纹理 - 高清纹理
基于Java的Swing飞机订票系统设计源码
04-18
本项目是基于Java的Swing飞机订票系统设计源码，包含102个文件，其中主要包含41个java源代码文件，26个png图片文件，10个jpg图片文件等。系统采用了Java编程语言，实现了基于Swing的飞机订票系统。项目结构清晰，代码可读性强，易于理解和维护。
求单源最短路不就是求最小生成树嘛
05-29
不是的，求单源最短路和求最小生成树是两个不同的问题。 最小生成树是指在一个加权无向图中，找到一棵生成树，使得所有边的权值之和最小。而求单源最短路则是指在一个加权有向图中，找到从给定起点到其他所有点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值