一. dijkstra 單源最短路徑演算法

• 前提條件： 圖中不能有負權邊
• 複雜度O(E log(V))
• 有向圖和無向圖都適用

演算法思路

概念說明：
鬆弛操作： 從0到1的最短距離， 上圖中 0-1為 5， 但是0-2 + 2-1 為3 這樣繞道而行更短， 則用0-2 + 2-1 的路徑代替  0-1


如上圖所示， 起始點為0

步驟1.   建立最小索引堆，存放對應點到0點的距離， 先將0放入
適用distTo陣列， 存放0點到該點的已知最短路徑。 distTo[0]=0, 其他distTo為null
最小索引堆：
0  
0  


步驟2.   取出最小索引堆中最小的值， 目前是0，從最小索引堆中取出的對應點都mark為true
遍歷0的相鄰點(mark的值true就跳過)， 1 2 3， 將0-1 0-2 0-3 存入最小索引堆。
此時distTo[1]=5, distTo[2]=2, distTo[3]=6
1  2  3
5  2  6



步驟3.   取出最小索引堆中最小的值， 目前是2， makr[2]=true
遍歷2的相鄰點(mark的值true就跳過)， 1 3 4，
對於1， 對比distTo[1] 是否> distTo[2] + 2-1   ,  distTo[1]為5 < distTo[2] + 2-1 即可以做鬆弛操作， 更新最小索引堆和distTo中1對應的值。 
對於3， 發現也可以做鬆弛操作， 重複對1的操作， 更新distTo[3]和最小索引堆中的值.
對於4， distTo[4]為null， 讓它=distTo[2] + 2-4     ,  同時將該值存入最小索引堆

1  3  4
3  5  7


步驟4. 重複步驟3， 直到最小索引堆為空
 

程式碼實現

Dijkstra.h

#ifndef INC_03_IMPLEMENTATION_OF_DIJKSTRA_DIJKSTRA_H
#define INC_03_IMPLEMENTATION_OF_DIJKSTRA_DIJKSTRA_H

#include <iostream>
#include <vector>
#include <stack>
#include "Edge.h"
#include "IndexMinHeap.h"

using namespace std;

// Dijkstra演算法求最短路徑
template<typename Graph, typename Weight>
class Dijkstra{

private:
    Graph &G;                   // 圖的引用
    int s;                      // 起始點
    Weight *distTo;             // distTo[i]儲存從起始點s到i的最短路徑長度
    bool *marked;               // 標記陣列, 在演算法執行過程中標記節點i是否被訪問
    vector<Edge<Weight>*> from; // from[i]記錄最短路徑中, 到達i點的邊是哪一條
                                // 可以用來恢復整個最短路徑

public:
    // 建構函式, 使用Dijkstra演算法求最短路徑
    Dijkstra(Graph &graph, int s):G(graph){

        // 演算法初始化
        assert( s >= 0 && s < G.V() );
        this->s = s;
        distTo = new Weight[G.V()];
        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            distTo[i] = Weight();
            marked[i] = false;
            from.push_back(NULL);
        }

        // 使用索引堆記錄當前找到的到達每個頂點的最短距離
        IndexMinHeap<Weight> ipq(G.V());

        // 對於起始點s進行初始化
        distTo[s] = Weight();// 呼叫weight預設建構函式  如果是int double等型別  會預設為0
        from[s] = new Edge<Weight>(s, s, Weight());
        ipq.insert(s, distTo[s] );
        marked[s] = true;
        while( !ipq.isEmpty() ){
            int v = ipq.extractMinIndex();

            // distTo[v]就是s到v的最短距離
            marked[v] = true;

            // 對v的所有相鄰節點進行更新
            typename Graph::adjIterator adj(G, v);
            for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() ){
                int w = e->other(v);
                // 如果從s點到w點的最短路徑還沒有找到
                if( !marked[w] ){
                    // 如果w點以前沒有訪問過,
                    // 或者訪問過, 但是通過當前的v點到w點距離更短, 則進行更新  即鬆弛操作
                    if( from[w] == NULL || distTo[v] + e->wt() < distTo[w] ){
                        distTo[w] = distTo[v] + e->wt();
                        from[w] = e;
                        if( ipq.contain(w) )
                            ipq.change(w, distTo[w] );
                        else
                            ipq.insert(w, distTo[w] );
                    }
                }
            }
        }
    }

    // 解構函式
    ~Dijkstra(){
        delete[] distTo;
        delete[] marked;
        delete from[0];
    }

    // 返回從s點到w點的最短路徑長度
    Weight shortestPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );
        return distTo[w];
    }

    // 判斷從s點到w點是否聯通
    bool hasPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        return marked[w];
    }

    // 尋找從s到w的最短路徑, 將整個路徑經過的邊存放在vec中
    void shortestPath( int w, vector<Edge<Weight>> &vec ){

        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );

        // 通過from陣列逆向查詢到從s到w的路徑, 存放到棧中
        stack<Edge<Weight>*> s;
        Edge<Weight> *e = from[w];
        while( e->v() != this->s ){
            s.push(e);
            e = from[e->v()];
        }
        s.push(e);

        // 從棧中依次取出元素, 獲得順序的從s到w的路徑
        while( !s.empty() ){
            e = s.top();
            vec.push_back( *e );
            s.pop();
        }
    }

    // 打印出從s點到w點的路徑
    void showPath(int w){

        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );

        vector<Edge<Weight>> vec;
        shortestPath(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i].v()<<" -> ";
            if( i == vec.size()-1 )
                cout<<vec[i].w()<<endl;
        }
    }
};

#endif //INC_03_IMPLEMENTATION_OF_DIJKSTRA_DIJKSTRA_H

 

邊的程式碼Edge.h

#ifndef INC_03_IMPLEMENTATION_OF_DIJKSTRA_EDGE_H
#define INC_03_IMPLEMENTATION_OF_DIJKSTRA_EDGE_H

#include <iostream>
#include <cassert>

using namespace std;

// 邊
template<typename Weight>
class Edge{
private:
    int a,b;    // 邊的兩個端點
    Weight weight;  // 邊的權值

public:
    // 建構函式
    Edge(int a, int b, Weight weight){
        this->a = a;
        this->b = b;
        this->weight = weight;
    }
    // 空的建構函式, 所有的成員變數都取預設值
    Edge(){}

    ~Edge(){}

    int v(){ return a;} // 返回第一個頂點
    int w(){ return b;} // 返回第二個頂點
    Weight wt(){ return weight;}    // 返回權值

    // 給定一個頂點, 返回另一個頂點
    int other(int x){
        assert( x == a || x == b );
        return x == a ? b : a;
    }

    // 輸出邊的資訊
    friend ostream& operator<<(ostream &os, const Edge &e){
        os<<e.a<<"-"<<e.b<<": "<<e.weight;
        return os;
    }

    // 邊的大小比較, 是對邊的權值的大小比較
    bool operator<(Edge<Weight>& e){
        return weight < e.wt();
    }
    bool operator<=(Edge<Weight>& e){
        return weight <= e.wt();
    }
    bool operator>(Edge<Weight>& e){
        return weight > e.wt();
    }
    bool operator>=(Edge<Weight>& e){
        return weight >= e.wt();
    }
    bool operator==(Edge<Weight>& e){
        return weight == e.wt();
    }
};

#endif //INC_03_IMPLEMENTATION_OF_DIJKSTRA_EDGE_H

 

最小索引堆的程式碼IndexMinHeap.h

#ifndef INC_03_IMPLEMENTATION_OF_DIJKSTRA_INDEXMINHEAP_H
#define INC_03_IMPLEMENTATION_OF_DIJKSTRA_INDEXMINHEAP_H

#include <iostream>
#include <algorithm>
#include <cassert>

using namespace std;

// 最小索引堆
template<typename Item>
class IndexMinHeap{

private:
    Item *data;     // 最小索引堆中的資料
    int *indexes;   // 最小索引堆中的索引, indexes[x] = i 表示索引i在x的位置
    int *reverse;   // 最小索引堆中的反向索引, reverse[i] = x 表示索引i在x的位置

    int count;
    int capacity;

    // 索引堆中, 資料之間的比較根據data的大小進行比較, 但實際操作的是索引
    void shiftUp( int k ){

        while( k > 1 && data[indexes[k/2]] > data[indexes[k]] ){
            swap( indexes[k/2] , indexes[k] );
            reverse[indexes[k/2]] = k/2;
            reverse[indexes[k]] = k;
            k /= 2;
        }
    }

    // 索引堆中, 資料之間的比較根據data的大小進行比較, 但實際操作的是索引
    void shiftDown( int k ){

        while( 2*k <= count ){
            int j = 2*k;
            if( j + 1 <= count && data[indexes[j]] > data[indexes[j+1]] )
                j += 1;

            if( data[indexes[k]] <= data[indexes[j]] )
                break;

            swap( indexes[k] , indexes[j] );
            reverse[indexes[k]] = k;
            reverse[indexes[j]] = j;
            k = j;
        }
    }

public:
    // 建構函式, 構造一個空的索引堆, 可容納capacity個元素
    IndexMinHeap(int capacity){

        data = new Item[capacity+1];
        indexes = new int[capacity+1];
        reverse = new int[capacity+1];

        for( int i = 0 ; i <= capacity ; i ++ )
            reverse[i] = 0;

        count = 0;
        this->capacity = capacity;
    }

    ~IndexMinHeap(){
        delete[] data;
        delete[] indexes;
        delete[] reverse;
    }

    // 返回索引堆中的元素個數
    int size(){
        return count;
    }

    // 返回一個布林值, 表示索引堆中是否為空
    bool isEmpty(){
        return count == 0;
    }

    // 向最小索引堆中插入一個新的元素, 新元素的索引為i, 元素為item
    // 傳入的i對使用者而言,是從0索引的
    void insert(int index, Item item){
        assert( count + 1 <= capacity );
        assert( index + 1 >= 1 && index + 1 <= capacity );

        index += 1;
        data[index] = item;
        indexes[count+1] = index;
        reverse[index] = count+1;
        count++;
        shiftUp(count);
    }

    // 從最小索引堆中取出堆頂元素, 即索引堆中所儲存的最小資料
    Item extractMin(){
        assert( count > 0 );

        Item ret = data[indexes[1]];
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    // 從最小索引堆中取出堆頂元素的索引
    int extractMinIndex(){
        assert( count > 0 );

        int ret = indexes[1] - 1;
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    // 獲取最小索引堆中的堆頂元素
    Item getMin(){
        assert( count > 0 );
        return data[indexes[1]];
    }

    // 獲取最小索引堆中的堆頂元素的索引
    int getMinIndex(){
        assert( count > 0 );
        return indexes[1]-1;
    }

    // 看索引i所在的位置是否存在元素
    bool contain( int index ){

        return reverse[index+1] != 0;
    }

    // 獲取最小索引堆中索引為i的元素
    Item getItem( int index ){
        assert( contain(index) );
        return data[index+1];
    }

    // 將最小索引堆中索引為i的元素修改為newItem
    void change( int index , Item newItem ){

        assert( contain(index) );
        index += 1;
        data[index] = newItem;

        shiftUp( reverse[index] );
        shiftDown( reverse[index] );
    }

};

#endif //INC_03_IMPLEMENTATION_OF_DIJKSTRA_INDEXMINHEAP_H

二. 負權邊和Bellman-Ford演算法

• 如果存在如下所示的 負權環，就不會存在最短路徑了
• 0-1-2-0 邊加起來為負
• 2-1-2 邊加起來為負

Bellman-Ford單源最短路徑演算法

• 前提： 圖中不能有負權環
• Bellman-Ford可以判斷圖中是否有負權環
• 複雜度O(EV)

判斷是否有負權邊：
如果一個圖沒有負權環，
從一點到另一點的最短路徑， 最多經過所有的V個頂點， 有V-1條邊
否則，存在頂點經過了兩次， 即存在負權環

演算法描述：
對一個點的一次鬆弛操作， 就是找到經過這個點的另外一條路徑， 多一條邊， 權值更小。
如果一個圖沒有負權環， 從一個點到另外一個點的最短路徑， 最多經過所有的V個頂點，有V-1條邊
對所有的點進行V-1次鬆弛操作。

對所有的點進行V-1次鬆弛操作後， 理論上就找到了從源點到其他所有點的最短路徑。
如果說還可以繼續做鬆弛操作， 所說原圖中有負權環。

程式碼實現

Bellmanford.h

#ifndef INC_05_IMPLEMENTATION_OF_BELLMAN_FORD_BELLMANFORD_H
#define INC_05_IMPLEMENTATION_OF_BELLMAN_FORD_BELLMANFORD_H

#include <stack>
#include <vector>
#include "Edge.h"

using namespace std;

// 使用BellmanFord演算法求最短路徑
template <typename Graph, typename Weight>
class BellmanFord{

private:
    Graph &G;                   // 圖的引用
    int s;                      // 起始點
    Weight* distTo;             // distTo[i]儲存從起始點s到i的最短路徑長度
    vector<Edge<Weight>*> from; // from[i]記錄最短路徑中, 到達i點的邊是哪一條
                                // 可以用來恢復整個最短路徑
    bool hasNegativeCycle;      // 標記圖中是否有負權環

    // 判斷圖中是否有負權環
    bool detectNegativeCycle(){

        for( int i = 0 ; i < G.V() ; i ++ ){
            typename Graph::adjIterator adj(G,i);
            for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
                if( from[e->v()] && distTo[e->v()] + e->wt() < distTo[e->w()] )  //還有點沒做鬆弛操作
                    return true;
        }

        return false;
    }

public:
    // 建構函式, 使用BellmanFord演算法求最短路徑
    BellmanFord(Graph &graph, int s):G(graph){

        this->s = s;
        distTo = new Weight[G.V()];
        // 初始化所有的節點s都不可達, 由from陣列來表示
        for( int i = 0 ; i < G.V() ; i ++ )
            from.push_back(NULL);

        // 設定distTo[s] = 0, 並且讓from[s]不為NULL, 表示初始s節點可達且距離為0
        distTo[s] = Weight();
        from[s] = new Edge<Weight>(s, s, Weight()); // 這裡我們from[s]的內容是new出來的, 注意要在解構函式裡delete掉

        // Bellman-Ford的過程
        // 進行V-1次迴圈, 每一次迴圈求出從起點到其餘所有點, 最多使用pass步可到達的最短距離
        for( int pass = 1 ; pass < G.V() ; pass ++ ){

            // 每次迴圈中對所有的邊進行一遍鬆弛操作
            // 遍歷所有邊的方式是先遍歷所有的頂點, 然後遍歷和所有頂點相鄰的所有邊
            for( int i = 0 ; i < G.V() ; i ++ ){
                // 使用我們實現的鄰邊迭代器遍歷和所有頂點相鄰的所有邊
                typename Graph::adjIterator adj(G,i);
                for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
                    // 對於每一個邊首先判斷e->v()可達
                    // 之後看如果e->w()以前沒有到達過， 顯然我們可以更新distTo[e->w()]
                    // 或者e->w()以前雖然到達過, 但是通過這個e我們可以獲得一個更短的距離, 即可以進行一次鬆弛操作, 我們也可以更新distTo[e->w()]
                    if( from[e->v()] && (!from[e->w()] || distTo[e->v()] + e->wt() < distTo[e->w()]) ){
                        distTo[e->w()] = distTo[e->v()] + e->wt();
                        from[e->w()] = e;
                    }
            }
        }

        hasNegativeCycle = detectNegativeCycle();
    }

    // 解構函式
    ~BellmanFord(){

        delete[] distTo;
        delete from[s];
    }

    // 返回圖中是否有負權環
    bool negativeCycle(){
        return hasNegativeCycle;
    }

    // 返回從s點到w點的最短路徑長度
    Weight shortestPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );
        return distTo[w];
    }

    // 判斷從s點到w點是否聯通
    bool hasPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        return from[w] != NULL;
    }

    // 尋找從s到w的最短路徑, 將整個路徑經過的邊存放在vec中
    void shortestPath( int w, vector<Edge<Weight>> &vec ){

        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );

        // 通過from陣列逆向查詢到從s到w的路徑, 存放到棧中
        stack<Edge<Weight>*> s;
        Edge<Weight> *e = from[w];
        while( e->v() != this->s ){
            s.push(e);
            e = from[e->v()];
        }
        s.push(e);

        // 從棧中依次取出元素, 獲得順序的從s到w的路徑
        while( !s.empty() ){
            e = s.top();
            vec.push_back( *e );
            s.pop();
        }
    }

    // 打印出從s點到w點的路徑
    void showPath(int w){

        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );

        vector<Edge<Weight>> vec;
        shortestPath(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i].v()<<" -> ";
            if( i == vec.size()-1 )
                cout<<vec[i].w()<<endl;
        }
    }
};

#endif //INC_05_IMPLEMENTATION_OF_BELLMAN_FORD_BELLMANFORD_H

三. 其他

最長路徑演算法

• 最長路徑問題不能有正權環
• 無權圖的最長路徑問題是指數級難度的。
• 對於有權環， 不能使用Dijkstra求最長路徑問題。
• 可以使用Bellman-Ford演算法， （對所有的權取負， 求得的最短路徑再取負，得到的就是最長路徑）