SPFA
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
很遗憾,大概是由于数据加强过的原因,原先能过的代码现在过不了了,只能 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
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
看一眼数据范围,发现这其实是一张稠密图,所以这个题用普通 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 采用动态规划的思想,设三维数组 m a p [ k ] [ i ] [ j ] map[k][i][j] map[k][i][j] 表示 i i i , j j j 两个点经过 1... k 1...k 1...k 点的最短路,注意这里的经过并不是说全部经过,而是经过 1... k 1...k 1...k 中的某个或某几个点组成的最短路径。初始化 m a p [ 0 ] [ i ] [ j ] map[0][i][j] map[0][i][j] 为原图的邻接矩阵,不相连的点之间的值为 I N F INF INF 。
考虑状态转移: m a p [ k ] [ i ] [ j ] map[k][i][j] map[k][i][j] 可以从 m a p [ k − 1 ] [ i ] [ j ] map[k-1][i][j] map[k−1][i][j] 转移过来,此时对应 i i i , j j j 两点不经过 k k k 的情况。 m a p [ k ] [ i ] [ j ] map[k][i][j] map[k][i][j] 还可以从 m a p [ k − 1 ] [ i ] [ k ] + m a p [ k − 1 ] [ k ] [ j ] map[k-1][i][k]+map[k-1][k][j] map[k−1][i][k]+map[k−1][k][j] 转移,此时对应经过 k k k 点的情况。
此时我们发现由于 k k k 只于 k − 1 k-1 k−1 有关,所以第一个维度可以去掉,而这必须要求我们在循环时把 k k k 放在最外层,以此来保证在更新 k k k 时, k − 1 k-1 k−1 可以全部更新完。