图论入门算法模板+分析+例题

最新推荐文章于 2024-08-08 15:12:59 发布

TralSun

最新推荐文章于 2024-08-08 15:12:59 发布

阅读量182

点赞数 1

分类专栏：算法笔记文章标签：图论算法

本文链接：https://blog.csdn.net/weixin_51692023/article/details/128602603

版权

本文详细介绍了图论中的最短路问题，包括Bellman-Ford算法、Dijkstra算法和Floyd-Warshall算法，讨论了它们的思路、适用条件和时间复杂度。此外，还讲解了最小生成树的Prim算法和Kruskal算法，并提供了例题和模板。

摘要由CSDN通过智能技术生成

一、最短路问题

单源最短路指的是固定起点和终点，求最短路。
下文中，v表示点的个数，e表示边的个数。

1.1 单源最短路问题1（Bellman-Ford算法）

思路

只要之前有边更新过，就继续遍历所有的边，更新最小值。

适用条件

适用任意情况，可存在负边、可存在负圈。由于一些边不会即使更新，反复检查导致浪费了一些时间，下文会介绍SPFA队列优化。

模板 $O (V E)$

const int MAX_V=1e5+200,MAX_E=5e5+200;
struct edge{
   
	int from,to,cost;
};
edge es[MAX_E];

void shortest_path(int s){
   
	memset(d,0x3f,sizeof d);
	d[s]=0;
	while(true){
   
		bool update=false;
		for(auto e:es){
   
			if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost){
   
				d[e.to]=d[e.from]+e.cost;
				update=true;
			}
		}
		if(!update)break;
	}
}

有步数限制的单源最短路

有边数限制的最短路 - AcWing题库

思路

每一次都遍历所有的边，但是要在之前的dis上进行比较和更新，因为本次遍历，上一条边可能对下一条边产生影响，这个影响是通过2步实现的，不符合我们一次遍历代表走一步的预期。所以每次遍历前，要copy dis数组。

代码

#include<bits/stdc++.h>
using namespace std;
const int M=1e4+200;
const int N=1e3;
const int INF=0x3f3f3f3f;
int n,m,k;
struct edge{
   
    int from,to,cost;
};
edge es[M];
int dis[N],last[N];

void bellman_ford(int s){
   
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    int t=k;
    bool ud=1;
    while(ud&&t--){
   
        ud=0;
        memcpy(last,dis,sizeof dis);
        for(int i=1;i<=m;++i){
   
            edge e=es[i];
            if(last[e.from]!=INF&&dis[e.to]>last[e.from]+e.cost){
   
                dis[e.to]=last[e.from]+e.cost;
                //cout<<"dis["<<e.to<<"]="<<dis[e.to]<<'\n';
                ud=1;
            }
        }
    }
}

int main(){
   
    cin>>n>>m>>k;
    for(int i=1;i<=m;++i){
   
        cin>>es[i].from>>es[i].to>>es[i].cost;
    }
    bellman_ford(1);
    if(dis[n]==INF)cout<<"impossible";
    else cout<<dis[n];
    return 0;
}

判断负圈存在

负圈

负圈就是某个环路存在负边，且负边能对最短路的结果确定造成影响，使之能不断减下去。

若负圈存在，则求最短路是没有意义的。
判断是否存在负圈，看一个点到另一个点的最短路边数是否能达到N，因为一共N个点，最多N-1条边能走完，出现N表示有负环。

方法一

遍历所有的边，遍历次数若为N则存在负环

bool find_negative_loop(){
   
	memset(d,0,sizeof d);//其实初始值不重要（当然在不能越界条件下），判断的是他们的相对值 
	for(int i=1;i<=V;++i){
   
		for(auto e:es){
   
			if(d[e.to]>d[e.from]+e.cost){
   
				d[e.to]=d[e.from]+e.cost;
				if(i==V)return true; //V个点最多循环V-1次确定所有最短路，除非存在负圈 
			}
		}
	}
	return false; 
}

方法二

spfa判断负环 - AcWing题库
把所有点看成起点，循环遍历。因为题目问的是图中是否存在环，而不是求某点到某点的最短距离。

#include<bits/stdc++.h>
using namespace std;

const int N=2200;
const int M=N*4;
const int INF=0x3f3f3f3f;
int n,m;
struct edge{
   int to,cost;};
struct node{
   int id,d;};
bool vis[N];
int cnt[N];
vector<edge>G[N];
int dis[N];

bool SPFA(int s){
   
    fill(dis,dis+N,INF);
    fill(vis,vis+N,true);
    dis[s]=0;
    queue<node>q;
    for(int i=1;i<=n;++i)q.push({
   i,dis[i]});
    while(!q.empty()){
   
        node v=q.front();q.pop();
        vis[v.id]=false;
        for(edge e:G[v.id]){
   
            if(dis[e.to]>dis[v.id]+e.cost){
   
                dis[e.to]