【图论算法】最短路，次短路，k短路总结

在图论里，最短路，次短路，k短路的问题很常见。
这里总结一下。

存图技巧

数据小，稠密图的一般用邻接矩阵
稀疏图，数据大一般用邻接表（vector,链式前向星都可)

邻接矩阵

const int maxn = 1e5+5;
int Graph[maxn][maxn];  // 正权图可以初始化成-1来判断是否连通，负权图可以再考虑开个数组或者用一个很大的值。

链式前向星

const int maxn = 1e5+5;
struct Edge{int u,v,nxt;
}edge[maxn];
int head[maxn],tot;
inline void addedge(int u,int v,int w){ // u->v 权值是wedge[++tot] = {u,v,w};head[u] = tot;
}

最短路

一般最短路算法有 BFS(暴力，一般只适用于点数小的情况),dijiastra(解决正权图),spfa(解决负权图，但容易死,被卡),floyed(解决点与点之间的最短距离问题,dp)

这里直接给出单源最短路的算法(因为都挺好理解的) (重点在于松弛操作!)

dijiastra

// 堆优化版本
const int maxn = 1e5+5;
struct Edge{int u,v,nxt,w;
}edge[maxn];
int head[maxn],tot;
inline void init(){memset(head,-1,sizeof(head));
}
inline void addedge(int u,int v,int w){edge[++tot] = {u,v,head[u],w};head[u] = tot;
}
int dis[maxn];  bool vis[maxn];
inline void dijiastra(int s){struct Node{int u,dis;bool operator <(const Node &h)const{return dis > h.dis;}};memset(dis,0x3f,sizeof(dis));   //  视具体情况而定初始化的值dis[s] = 0;priority_queue<Node> pq;    pq.push(Node{s,0});while(!pq.empty()){Node u = pq.top();  pq.pop();if(vis[u.u])    continue;vis[u.u] = true;for(int i = head[u.u]; ~i; i = edge[i].nxt){Edge &e = edge[i];if(dis[e.v] > u.dis + e.w){dis[e.v] = u.dis + e.w;pq.push(Node{e.v,dis[e.v]});}}}
}

spfa

struct Edge{int v,d;Edge(int vv,int dd):v(vv),d(dd){}
};
struct Node{int u,cost;Node(int uu,int cc):u(uu),cost(cc){}bool operator < (const Node & h)const{return cost > h.cost;}
};
const int MAX = 1e5+5;
vector < Edge > edges;
vector < int > Graph[MAX];
bool vis[MAX];
int dp[MAX];
void AddEdge(int u,int v,int dis){edges.push_back(Edge{v,dis});Graph[u].push_back(edges.size()-1);
}
void SPFA(int s,int n){memset(dp,0x3f,sizeof(dp));dp[s-1] = 0;priority_queue<Node>q ;q.push(Node{s-1,0});  vis[s-1] = 1;while(!q.empty()){Node x = q.top(); q.pop();int u = x.u; vis[u] = 0; // cancel the tag;for(int i = 0; i < Graph[u].size(); ++i ){Edge & e = edges[Graph[u][i]];if( dp[e.v] > dp[u]+ e.d ){dp[e.v] = dp[u] + e.d;if(!vis[e.v]) q.push(Node{e.v,dp[e.v]});vis[e.v] = 1;}}}
}

次短路(利用最短路来求)

目前见到的方法一般有两种，遍历or删边

1.删边。
首先使用最短路算法求出s−ts - ts−t的最短路,并且记录下最短路的路径(在松弛的时候记录前驱)，然后对于这条路径，我们依次去删去一条边，然后跑最短路，去更新ans

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
const double inf = 1e9+5;
struct Edge{int u,v,nxt;    double w;
}edge[maxn];
int head[maxn],tot;
pair<int,int> path[maxn];
inline void addedge(int u,int v,double w){edge[++tot] = {u,v,head[u],w};head[u] = tot;
}
inline void init(){memset(head,-1,sizeof(head));tot = 0;
}double dis[maxn];   bool vis[maxn];
bool isok[maxn];
inline void dijiastra(int s){struct Node{int u;  double dis;bool operator <(const Node &h)const{return dis > h.dis;}};for(int i = 0; i < maxn; ++i)  dis[i] = inf,vis[i] = false;priority_queue<Node> pq;    pq.push(Node{s,0});while(!pq.empty()){Node u = pq.top();  pq.pop();if(vis[u.u])continue;vis[u.u] = true;for(int i = head[u.u]; ~i; i = edge[i].nxt){if(isok[i]) continue;Edge &e = edge[i];if(dis[e.v] > u.dis + e.w){ //  松弛过程中记录dis[e.v] = u.dis + e.w;path[e.v] = make_pair(u.u,i);pq.push(Node{e.v,dis[e.v]});}}}
}
struct Point{int x,y;
}p[maxn];
inline double get_dis(const Point &p,const Point&q){return sqrt( (p.x-q.x)*(p.x-q.x) + (p.y-q.y)*(p.y-q.y));
}
int main()
{ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);init();int n,m;    cin >> n >> m;for(int i = 1; i <= n; ++i) cin >> p[i].x >> p[i].y;for(int i = 0,u,v; i < m; ++i){cin >> u >> v;  double d = get_dis(p[u],p[v]);addedge(u,v,d); addedge(v,u,d);}dijiastra(1);pair<int,int> tt = path[n];vector<int> ee; ee.push_back(tt.second);while(tt.first!=1){tt = path[tt.first];ee.push_back(tt.second);}double ans = inf;for(int i = 0; i < ee.size(); ++i){isok[ee[i]] = true;dijiastra(1);isok[ee[i]] = false;ans = min(ans,dis[n]);}if(ans==inf){cout << -1 << endl;}else cout <<fixed<<setprecision(2)<< ans << endl;return 0;
}

2.遍历。
跑两次最短路，分别是以起点，以终点。然后遍历所有边，去更新长度
∑e(u,v)∈G(v,e)min(dis[1][u]+w(u,v)+dis[v][n])\sum_{e(u,v)\in G(v,e)}min(dis[1][u]+w(u,v)+dis[v][n])∑e(u,v)∈G(v,e)min(dis[1][u]+w(u,v)+dis[v][n])

k短路 ( A*或者左偏树)（当然也可以用于解决次短路问题)

左偏树，A*待更新

左偏树学习：大佬博客