图的那些事儿——Dijkstra和Floyd

最短路问题

Dijkstra算法
说到最短路问题，我相信只要是学习过计算机的人都有据说过Dijkstra他老人家，他对程序的贡献远不止一个算法。

1 提出“goto有害论”;
2 提出信号量和PV原语;
3 解决了“哲学家聚餐”问题;
4 最短路径算法(SPF)和银行家算法的创造者;
5 第一个Algol 60编译器的设计者和实现者;
6 THE操做系统的设计者和开发者;

按照他本身的称呼，他是一个程序员。不得不说，这样的程序员实在是太伟大了。

让咱们回到Dijkstra算法上。
这个算法的核心是维护d[i]=>i号结点和起点s距离的估值，之因此是估值，是由于它可能并非真的最短值。要经历一个过程，才可以成为真正的最短值。

此次咱们先看算法好了。

清除全部点的标号(全部点都是未知的)
设d[0]=0,d[i]=INF（无限大）
循环n次{
    #在未知的点中，寻找出d值最小的结点x
    *标记x为已知
    对于从x出发的全部边（x,y）更新 d[y]=min(d[y],d[x]+w[x][y])   
}

咱们看到了这个过程（标了*号的这一行）。
是当d[x]为当前全部未知点中的最小值时，别的全部的到达x的走法都是绕远路、舍近求远。因此，这时咱们能够肯定 d[x]就是x点和起点s的最短距离！
咱们来写一个简单的版本好了

//v 标记是否已知
//
memset(v,0,sizeof(v));
for(int i=0;i<n;i++) d[i]=(i==0?0:INF);
for(int i=0;i<n;i++){
    int x,m=INF;
    /*查找未知点中d值最小的结点x*/
    for(int j=0;j<n;j++)if(v[j]&&d[j]<m) m=d[x=j];
    v[x]=1;
    /*以x为中间点，更新别的点的d值*/
    for(int k=0;k<n;k++) d[k]=min(d[k],d[x]+w[x][k]); 
}

代码中带有注释的两处其实均可以优化。
查找最小结点这种工做其实对于一个优先队列来讲很是合适。
这个队列中拥有d值以及其对应的结点号（d[i]和i）
还须要定义>操做符

struct HeapNode{
    int d,i;
    bool operator < (const HeapNode& rhs) const{
        return d>rhs.d; 
    } 
}

在正式完成算法以前，咱们首先对数据结构进行些许该进。另外一个能够优化的地方也在这里，将w[i][j]这样一个N^2的数组转换为一个vector< int> Gi[maxn]来存储边号，用vector< Edge> Edges来存储边。

struct Edge{
    int from,to;
    int dist;
    Edge(int x,int y,int d):from(u),to(v),dist(d){}
}

struct Dijstra{
    vector<int> G[maxn];
    vector<Edge> edges;
    int m,n;
    int d[mniaxn],v[maxn];
    int p[maxn];/*保存父结点*/
    void init(int n){
        this->n=n;
        for(auto item:G)item.clear();
        edges.clear();
    }
    void AddEdge(int from,int to,int dist){
        edges.push_back(Edge(from,to,dist));
        m=edges.size();
        G[from].push_back(m-1);/*m-1恰好为这个边在edges中的索引*/
    }
    void dijkstra(int s){
    ...
    }
}

主算法：

void Dijkstra(int s){
    priority_queue<HeapNode> Q;
    for(int i=0;i<n;i++) d[i]=INF;
    d[s]=0;
    memset(done,0,sizeof(done));
    Q.push((HeadNode){0,s});
    while(!Q.empty()){
        HeapNode x=Q.top();Q.pop();
        int u=x.u;
        if(done[u]) continue;
        done[u]=true;
        for(int i=0;i<G[u].size();i++){
            Edge& e=edge[G[u][i]];
            if(d[e.to]>d[u]+e.dist){
             d[e.to]=d[u]+e.dist;
             p[e.to]=G[u][i];
             Q.push((HeapNode){d[e.to],e.to})
            }
        }
    }
}

是否是有点累了呢。不要紧，只要看懂了第一段代码，对Dijkstra的贪心思想熟记于心就能够了！
可是Dijkstra算法在面对有负权边时就无能为力了，有负环的话就意味着最短路径不存在！
这个时候咱们须要另外一种算法Bellman-Ford算法
Bellman-Ford
咱们先直接上代码看看

for(int i=0;i<n;i++) d[i]=INF;
d[0]=0;
for(int k=0;k<n-1;k++)//迭代n-1次
    for(int i=0;i<m;i++)//检查每条边
    {
        int x=u[i],y=v[i];
        if(d[x]<INF) d[y]=min(d[y],d[x]+w[i]);//松弛
    }

须要指出的是：Bellman-Ford算法很是低，其优化这里先不给出

咱们应该关注的重点在于Floyd算法：

for(int k=0;k<n;k++)//做为中点
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            d[i][j]=min(d[i][j],d[i][k]+d[k][j]);//松弛

Floyd求出的是各个点对的距离。