最短路径

• 单源最短路之Dijkstra算法

所谓“单源最短路”是指只有唯一起点的最短路问题。常用的有朴素的Dijkstra算法写法和加了堆优化的写法，分别对应于稀疏图和稠密图的情况。

朴素的dijkstra算法，复杂度为O(V²)。

const int INF = INT_MAX;  
int d[N],vis[N];  
int w[N][N];  
  
void dijkstra(int s, int n)  
{  
    memset(vis,0,sizeof(vis));  
    for(int i=1; i<=n; i++) d[i] = (i==s ? 0 : INF);  
    for(int i=1; i<=n; i++) {  
        int x,m = INF;  
        for(int j=1; j<=n; j++)  
            if(!vis[j] && d[j]<m)  
            m = d[x=j];  
        vis[x] = 1;  
        for(int j=1; j<=n; j++)  
            if(d[j] < d[x]+w[x][j])  
            d[j] = d[x] + w[x][j];  
    }  
}  

使用邻接表和优先队列优化的Dijkstra算法，复杂度为O(ElogV)，因此它适用于E远小于V²的稀疏图。

const int INF = INT_MAX;  
struct Edge {  
    int from, to, w;  
    Edge(){}  
    Edge(int a, int b, int c):from(a),to(b),w(c){}  
};  
vector<Edge>edges;  
vector<int>G[N];  
void AddEdge(int from, int to, int w)  
{  
    edges.push_back(Edge(from,to,w));  
    edges.push_back(Edge(to,from,w));  
    int m = edges.size();  
    G[from].push_back(m-2);  
    G[to].push_back(m-1);  
}  
int vis[N],d[N],w[N][N];  
typedef pair<int,int> pii;  
priority_queue<pii,vector<pii>,greater<pii> >q;  
void dijkstra(int s, int n)  
{  
    memset(vis,0,sizeof(vis));  
    for(int i=1; i<=n; i++) d[i] = (i==s ? 0 : INF);  
    while(!q.empty()) q.pop();  
    q.push(make_pair(d[s],s));  
    while(!q.empty()) {  
        pii u = q.top(); q.pop();  
        int x = u.second;  
        if(vis[x]) continue;  
        vis[x] = 1;  
        for(int i=0; i<G[x].size(); i++) {  
           Edge &e = edges[G[x][i]];  
           if(d[e.to] > d[x] + e.w)  
               d[e.to] = d[x] + e.w,  
               q.push(make_pair(d[e.to],e.to));  
        }  
    }  
}  
  

• 单源最短路之Bellman-Ford 算法

对于带负权边的图，Dijkstra算法便无能为力了，而Bellman-Ford算法可以解决这个问题 。

Bellman-Ford算法的一般写法也有两种，朴素式写法和使用FIFO队列优化的写法。

朴素的Bellman-Ford算法，复杂度为O(VE)。

int u[M],v[M],w[M];  
int d[N];  
bool BF(int s, int n, int m)  //s:源点 n:点个数 m:边个数  
{  
    for(int i=1; i<=n; i++) d[i] = (i==s ? 0 : INF);  
    for(int k=1; k<n; k++) {    //n-1次松弛  
        for(int i=1; i<=m; i++) //检查每条边  
        {  
            int x = u[i], y = v[i];  
            if(d[x] < INF) d[y] = min(d[y],d[x]+w[i]);  
        }  
    }  
    for(int k=1; k<=n; k++) {  //判负环  
        for(int i=1; i<=m; i++)  
        {  
            int x = u[i], y = v[i];  
            if(d[x] < INF && d[y] > d[x] + w[i])  
                return false;  
        }  
    }  
    return true;  
}  

1994年，西南交通大学的段凡丁发表了SPFA算法，其实质是使用FIFO队列优化后的Bellman-Ford算法。其论文指出该SPFA算法的时间复杂度可降至O(KE)，E指边的个数，而K是一个很小的常数，但他对该复杂度的证明是不严谨甚至是错误的。事实上，在Bellman算法的论文中已有这方面的内容。实践中，该算法的效果很不稳定，也没有得到国际上的认可。

int inq[N],d[N];  
int sum[N];  //记录点出入队列的次数  
vector<Edge>edges;  
vector<int>G[N];  
bool BF(int s, int n)  
{  
    queue<int>q;  
    for(int i=1; i<=n; i++) d[i] = (i==s ? 0 : INF);  
    memset(inq,0,sizeof(inq));  
    memset(sum,0,sizeof(sum));  
    sum[s] = 1;  
    q.push(s);  
    while(!q.empty()) {  
        int x = q.front(); q.pop();  
        inq[x] = 0;  
        for(int i=0; i<G[x].size(); i++) {  
            Edge &e = edges[G[x][i]];  
            if(d[e.to] > d[x] + e.w) {  
                d[e.to] = d[x] + e.w;  
                if(!inq[e.to]) {  
                    if(++sum[e.to] == n) return false;  
                    inq[e.to] = 1;  
                    q.push(e.to);  
                }  
            }  
        }  
    }  
    return true;  
}  
  

• Floyd算法

Floyd算法可以求出图中任意两点之间的最短路径且不管边权是否为负，复杂度O(V³)。

int d[N][N];  
void Floyed(int n)  
{  
    for(int k=1; k<=n; k++)   
        for(int i=1; i<=n; i++)  
            for(int j=1; j<=n; j++)  
            if(d[[i][k]!=INF && d[k][j]<INF)  
            d[i][j] = min(d[i][j],d[i][k]+d[k][j]);  
}  

--Floyd算法应用之最小环

根据Floyd算法的思路，我们可以在求出最短路的同时得到该图中的最小环，即路径最短的环形线路。

Floyed算法是按照点的编号增加的顺序更新最短路的， 假设环的最大号点是u，相邻两点为i,j,则在用u点更新 d[i][j]前，d[i][j] = w[i][u] + w[u][j],一定是一个 环。

int d[N][N],w[N][N];  
void MinCircle(int n)  
{  
    for(int k=1; k<=n; k++)   
    {  
        for(int i=1; i<=n; i++)  //最小环判定  
            for(int j=1; j<=n; j++)  
            if(d[i][j]!=INF && w[i][k]!=INF && w[k][j]!=INF  
               && d[i][j] + w[i][k] + w[k][j] < mincircle)  
               mincircle = d[i][j] + w[i][k] + w[k][j];  
        for(int i=1; i<=n; i++)  //Floyed部分  
            for(int j=1; j<=n; j++)  
            if(d[i][k]!=INF && d[k][j]!=INF)  
            d[i][j] = min(d[i][j],d[i][k]+d[k][j]);  
    }  
}