8.12 最短路的基本算法

Bellman_Ford

算法的原理是对图进行n-1次松弛操作，得到所有可能的最短路径。
即循环nm次，查询1次可以到达起点的距离，再更新结点距离，与dijkstra算法的思想类似。

优点：
优于Dijkstra算法的方面，是边的权值可以为负数。
缺点：
时间复杂度过高，高达O(nm)。

基础Bellman_Ford

//基础Bellman_Ford
#include<bits/stdc++.h>
using namespace std;
const int N=1005;

int dis[N];
int n,m;

struct Edge{
	int a,b,w;
}edge[N];

void Bellman_Ford(int s)
{
	memset(dis,0x3f,sizeof dis);
	dis[s] = 0;
	
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			if(dis[b]>dis[a]+w) dis[b] = dis[a]+w; 
		}
	}
	return;
}

int main()
{
	cin>>n>>m;
	while(m--)
	{
		int a,b,w;
		cin>>edge.a>>edge.b>>edge.w; 
	}
	Bellman_Ford(1);
}

有边数限制的Bellman_Ford

如果只查找k条边就能到达的结点数，对基础贝尔曼进行一些限制可以实现。

如果单纯改动代码，使其内层循环k次，看似可以，但外层循环已经查找了所有边数的情况。
这时，就需要设置一个backup数组，来记录上一次更新的位置。不在原数组上进行改动。

//有边数限制的Bellman_Ford 
#include<bits/stdc++.h>
using namespace std;
const int N=1005;

int dis[N],backup[N];
int n,m;

struct Edge{
	int a,b,w;
}edge[N];

int Bellman_Ford(int s)
{
	memset(dis,0x3f,sizeof dis);
	dis[s] = 0;
	
	for(int i=0;i<k;i++)
	{
		memcpy(backup,dis,sizeof dis);//memcpy复制dis到backup
		for(int j=0;j<m;j++)
		{
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			if(dis[b]>dis[a]+w) dis[b] = min(dis[b],backup[a]+w);
		}
	}
	if(dis[n] > 0x3f3f3f3f / 2) return -1;
	return dis[n];
}

int main()
{
	cin>>n>>m;
	while(m--)
	{
		int a,b,w;
		cin>>edge.a>>edge.b>>edge.w; 
	}
	Bellman_Ford(1);
}

---

SPFA

SPFA算法主要用于判断负环。没有负环时不要用此代码，容易超时！

SPFA就是优化版的贝尔曼算法。
算法思想：通过前驱结点来缩小后继节点到起点的距离。
将遍历过的点入队，再遍历入队的点的后继节点，继续重复此操作。

//spfa判断负环 
#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
using namespace std;

const int N=2e3+5;
int dis[N],cnt[N]; //起点到其他点的最短距离，起点到其他点的边数 
bool st[N];
queue<int> q;

typedef pair<int, int> PII;
int T,n,m;
vector<PII> g[N];

void add(int a,int b,int w)
{
	g[a].push_back({w,b});
}

int spfa(int s)
{

	q.push(1);//题目求从1开始能到达的负环，所以只推入1号结点 
	st[1] = 1;
	dis[1] = 0;
	while(q.size())
	{
		int t = q.front();
		q.pop();
		
		st[t]  = false;
		for(int i=0;i<g[t].size();i++)
		{
			int j = g[t][i].second, distance = g[t][i].first;
			if(dis[j]>dis[t]+distance)
			{
				cnt[j] = cnt[t]+1;
				//cout<<cnt[j]<<" ";
				dis[j] = dis[t] + distance;
		
				if(cnt[j]>=n)//如果边数>=n，则出现环 
				{
					cout<<"YES"<<endl;
					return true;
				}
				if(!st[j])
				{
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	cout<<"NO"<<endl; 
	return false;
} 

int main()
{
	cin>>T;
	while(T--)
	{
		//多组输入数据，每次都要将所有数组初始化
		for(int i=0;i<N;i++)
		{
			g[i].clear();
		}
		while(!q.empty()) q.pop();
		memset(dis,0x3f,sizeof dis);
		memset(cnt,0,sizeof cnt);
		memset(st,0,sizeof st);
		
		cin>>n>>m;
		
		while(m--)
		{
			int a,b,w;
			cin>>a>>b>>w;
			add(a,b,w);
			if(w>=0) add(b,a,w);
		}
		spfa(1);
	}
}

千 万 不 要 在 没 有 负 环 时 用 它 ！最坏情况会 退 化 超 时 ！

---

Floyd

弗洛伊德算法，用于求任意两点之间的最短路。

第一层循环，遍历n个点。
内层两个循环，遍历n个点的点对。

//floyd
void floyd()
{
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)//遍历所有点对 
		{
			for(int j=1;j<=n;j++)//松弛（现距离<原距离，更新长度为现距离。） 
			{
				arr[i][j] = min(arr[i][j],arr[i][k]+arr[k][j]);
			}
		}
	}
}

代码挺少嘟 理解不了就背