图论算法----最短路

经典算法

单源最短路：

1.Bellman_ford（可判负环，可有负边）

d[i]表示起点S到i的最短路，那么d[i]=min{d[j]+w[j][i]}且存在j->i的边代价为w[j][i]

经过证明如果不存在负圈最多通过V-1次松弛就可以完成复杂度O(V*E)(V为结点数，E为边数)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<vector>
#define maxn 50010
#define maxm 100010
#define INF 0x3fffffff
using namespace std;
struct edge{
    int from,to,w;
    edge(){}
    edge(int _u,int _v,int _w){
        from=_u,to=_v,w=_w;
    }
};
edge G[maxm];
int V,E;
void addedge(int u,int v,int w){
    G[E++]=edge(u,v,w);
}
int d[maxn];
int n,m;
//d[i] = min{d[j]+w[j][i]} {j->i}
void bellman_ford(int s){
    V=n;
    for(int i=0;i<V;++i)d[i]=INF;
    d[s]=0;
    while(1){
        bool flag =false;
        for(int i=0;i<E;++i){
            edge e = G[i];
            if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.w){
                d[e.to] = d[e.from]+e.w;
                flag = true;
            }
        }
        if(!flag)break;
    }
}
int main (){
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0&&m==0)break;
        int u,v,w;
        E=0;
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&u,&v,&w);
            addedge(u-1,v-1,w);
            addedge(v-1,u-1,w);
        }
        bellman_ford(0);
        printf("%d
",d[n-1]);
    }
}

判负环：看一下是不是多于V-1次松弛，如果有则存在负环

bool HaveNagativeLoop(){
    memset(d,0,sizeof(d));
    for(int i=0;i<V;++i){
        for(int j=0;j<E;++j){
            edge e = G[j];
            if(d[e.to]>d[e.from]+e.w){
                d[e.to] = d[e.from]+e.w;
                if(i==V-1)return true;
            }
        }
    }
    return false;
}

 2.dijkstra(无负边)

对于上述的d[i]=min{d[j]+w[j][i]}如果d[j]当前值不是d[j]能达到的最小值那么显然在后面d[i]还将更新，如何避免这种情况

选择d[j]已经是最小，即S->j的最短距离不再更新，如何选取？每次选择距离最短且未被使用的结点，用这个结点对其他节点进行松弛复杂度O(V*V)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<vector>
#define maxn 1010
#define maxm 100010
#define INF 0x3fffffff
using namespace std;
//d[i]=min{d[j]+w[j][i]} {d[j]已经不再更新}
//每次找最小d[j]然后松弛
int G[maxn][maxn];
int d[maxn];
bool used[maxn];
int V;
void dijksta(int s){
    for(int i=0;i<V;++i){
        used[i]=false;
        d[i]=INF;
    }
    d[s]=0;
    while(1){
        int v =-1;
        for(int i=0;i<V;++i){
            if(!used[i]&&(v==-1||d[i]<d[v]))v=i;
        }
        if(v==-1)break;
        used[v]=true;
        for(int i=0;i<V;++i){
            d[i]=min(d[i],d[v]+G[v][i]);
        }
    }
}
void init(int n){
    V = n;
    for(int i=0;i<V;++i){
        for(int j=0;j<V;++j){
            if(i==j)G[i][j]=0;
            else G[i][j]=INF;
        }
    }
}
int main (){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0&&m==0)break;
        int u,v,w;
        init(n);
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&u,&v,&w);
            G[u-1][v-1]=w;
            G[v-1][u-1]=w;
        }
        dijksta(0);
        printf("%d
",d[n-1]);
    }
}

 来优化一下上面的算法，每次需要选择最短的一个结点，这个可以使用一个优先队列来维护当前所有边里面权值最小的边，所以算法复杂度变为O(V*log(E))

使用邻接表存储图比较容易写

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<vector>
#define maxn 1010
#define maxm 100010
#define INF 0x3fffffff
using namespace std;
struct edge {
    int to,w;
    edge(){}
    edge(int _to,int _w){
        to=_to;w=_w;
    }
};
typedef pair<int,int> P;
int V;
vector<edge> G[maxn];
int d[maxn];
void dijkstra(int s){
    priority_queue<P,vector<P>,greater<P> >q;
    for(int i=0;i<V;++i)d[i]=INF;
    d[s]=0;
    q.push(P(d[s],s));
    while(!q.empty()){
        P p = q.top();
        q.pop();
        int v = p.second;
        if(d[v]<p.first)continue;
        for(int i=0;i<G[v].size();++i){
            edge e = G[v][i];
            if(d[e.to]>d[v]+e.w){
                d[e.to]=d[v]+e.w;
                q.push(P(d[e.to],e.to));
            }
        }
    }
}
int main (){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        for(int i=0;i<n;++i)G[i].clear();
        V=n;
        if(n==0&&m==0)break;
        int u,v,w;
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&u,&v,&w);
            G[u-1].push_back(edge(v-1,w));
            G[v-1].push_back(edge(u-1,w));
        }
        dijkstra(0);
        printf("%d
",d[n-1]);
    }
}

 3.floyd(任意两点的最短路，可有负边)

dp的思想   d[k+1][i][j]表示从0~k 里面选择中间结点从i到j的最短距离 那么当k为-1时d[0][i][j]=w[i][j] 

考虑如何转移 从0~k-1中间选到0~k中选新的方案有两种情况：

不经过第k个结点 那么 d[k+1][i][j]=d[k][i][j]

经过第k个结点   那么d[k+1][i][j] = d[k][i][k]+d[k][k][j]

则方程为d[k+1][i][j]=min{ d[k][i][j]，d[k][i][k]+d[k][k][j]}

可以使用滚动数组来优化空间，由于d[k+1][][]只与d[k][][]有关，所以只要保证k是从小到大枚举的就可以节省以为空间，复杂度为O(V*V*V)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include<vector>
#define maxn 1010
#define maxm 100010
#define INF 0x3fffffff
using namespace std;
int d[maxn][maxn];
int V;
void init(int n){
    V=n;
    for(int i=0;i<V;++i){
        for(int j=0;j<V;++j){
            if(i==j)d[i][j]=0;
            else d[i][j]=INF;
        }
    }
}
void floyd(){
    for(int k=0;k<V;++k){
        for(int i=0;i<V;++i){
            for(int j=0;j<V;++j){
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}
int main (){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0&&m==0)break;
        int u,v,w;
        init(n);
        for(int i=0;i<m;++i){
            scanf("%d%d%d",&u,&v,&w);
            d[u-1][v-1]=w;
            d[v-1][u-1]=w;
        }
        floyd();
        printf("%d
",d[0][n-1]);
    }
}