算法整理 & 复习：最短路、次短路

洛谷博客 最短路
洛谷博客 次短路

---

SPFA

P3371 【模板】单源最短路径（弱化版）

void SPFA(int s){
	memset(dis,0x3f,sizeof(dis));
	queue <int>que;
	que.push(s);
	vis[s] = 1;
	dis[s] = 0;
	while(!que.empty()){
		int u = que.front();
		vis[u] = 0;
		que.pop();
		for(int k=head[u];k;k=map[k].next){
			int v = map[k].to;
			int w = map[k].w;
			if(dis[v] > dis[u]+w){
				dis[v] = dis[u]+w;
				if(!vis[v]){
					que.push(v);
					vis[v] = 1;
				}
			}
		}
	}
}

dfs 版 SPFA

P1993 小 K 的农场

很遗憾，大概是由于数据加强过的原因，原先能过的代码现在过不了了，只能 90 分，不过深搜版的 SPFA 应用并不多，简单练一练就好。

这个题还用了差分约束。

bool dfs_SPFA(int u){
	vis[u] = 1;
	for(int k=head[u];k;k=map[k].next){
		int v = map[k].to;
		int w = map[k].w;
		if(dis[v] > dis[u]+w){
			dis[v] = dis[u]+w;
			if(vis[v] || !dfs_SPFA(v)) return 0;
		}
	}
	vis[u] = 0;
	return 1;
}

---

Dijkstra

P3371 【模板】单源最短路径（弱化版）

void Dijkstra(int s){
	memset(dis,0x3f,sizeof(dis));
	int u,min;
	dis[s] = 0;
	for(int i=1;i<=n;i++){
		min = 0x3f3f3f3f;
		for(int k=1;k<=n;k++){
			if(!vis[k] && min>dis[k]){
				min = dis[k];
				u = k;
			}
		}
		vis[u] = 1;
		for(int k=head[u];k;k=map[k].next){
			int v = map[k].to;
			int w = map[k].w;
			if(dis[v] > dis[u]+w && !vis[v]){
				dis[v] = dis[u]+w;
			}
		}
	}
}

堆优化的 Dijkstra

P1186 玛丽卡

看一眼数据范围，发现这其实是一张稠密图，所以这个题用普通 Dij 才可以过，用堆优化其实是负优化，放在这里长个记性。

#include <stdio.h>
#include <queue>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 500005

int n,m,flag,ans;
int SP[MAXN];

int cnt;
int head[MAXN];

struct node{
	int from,to,next,w;
}map[2*MAXN];

void add(int u,int v,int w){
	map[++cnt] = (node){u,v,head[u],w};
	head[u] = cnt;
}

int vis[MAXN],dis[MAXN];

#define PII pair<int,int>
priority_queue <PII,vector<PII>,greater<PII> > que;

void heap_Dijkstra(int x, int y){
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0   ,sizeof(vis));
	que.push(make_pair(0,1));
	dis[1] = 0;
	while(!que.empty()){
		int u = que.top().second;
		que.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for(int k=head[u];k;k=map[k].next){
			int v = map[k].to;
			int w = map[k].w;
			if((u==x && v==y) || (u==y && v==x)) continue;
			if(dis[v] > dis[u]+w && !vis[v]){
				dis[v] = dis[u]+w;
				if(!flag) SP[v] = k;
				que.push(make_pair(dis[v],v));
			}
		}
	}
}

int main(void){
	memset(map,0x3f,sizeof map);
	cin >> n >> m;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin >> u >> v >> w;
		add(u,v,w);
		add(v,u,w);
	}
	heap_Dijkstra(0,0);
	flag = 1;
	for(int k=SP[n];k;k=SP[map[k].from]){
		int u = map[k].from;
		int v = map[k].to;
		heap_Dijkstra(u,v);
		ans = max(ans,dis[n]);
	}
	cout << ans;
	return 0;
}

---

Floyd

Floyd 算法不能解决带有负环的图。可有效解决稠密图。

void Floyd(){
    for(int k=1;k<=n;k++) 
	    for(int i=1;i<=n;i++)       
	    	for(int j=1;j<=n;j++)
	        	map[i][j] = min(map[i][j],map[i][k]+map[k][j]);
}

Floyd 采用动态规划的思想，设三维数组 $map[k][i][j]$ 表示 $i$ , $j$ 两个点经过 $1...k$ 点的最短路，注意这里的经过并不是说全部经过，而是经过 $1...k$ 中的某个或某几个点组成的最短路径。初始化 $map[0][i][j]$ 为原图的邻接矩阵，不相连的点之间的值为 $INF$ 。

考虑状态转移： $map[k][i][j]$ 可以从 $map[k-1][i][j]$ 转移过来，此时对应 $i$ , $j$ 两点不经过 $k$ 的情况。$map[k][i][j]$ 还可以从 $map[k-1][i][k]+map[k-1][k][j]$ 转移，此时对应经过 $k$ 点的情况。

此时我们发现由于 $k$ 只于 $k-1$ 有关，所以第一个维度可以去掉，而这必须要求我们在循环时把 $k$ 放在最外层，以此来保证在更新 $k$ 时， $k-1$ 可以全部更新完。

---

返回