【图论算法】 最短路，次短路，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 权值是w
		edge[++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-t$的最短路,并且记录下最短路的路径(在松弛的时候记录前驱)，然后对于这条路径，我们依次去删去一条边，然后跑最短路，去更新ans

#include
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.遍历。
跑两次最短路，分别是以起点，以终点。 然后遍历所有边，去更新长度
${\sum }_{e(u,v)\in G(v,e)}min(dis[1][u]+w(u,v)+dis[v][n])$

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

左偏树，A*待更新

左偏树学习：大佬博客