Dijkstra 算法

dijkstra算法，最简单的实现需要$O(|V|^2)$。用binary heap实现，可以优化到O((|V|+|E|)lg|V|)，如果用fibonacci heap的话，可以优化到O(|E|+|V|lg|V|)。如果图是密集图的话，那这个优化效果也不好，接近$O(|V|^2)$。

fibonacci heap不涉及删除元素的操作有O(1)的平摊时间。 Extract-Min和Delete的数目和其它相比，较小时效率更佳。稠密图每次decrease key只要O(1)的平摊时间，和二项堆的O(lg n)相比是巨大的改进。

For any implementation of vertex set Q the running time is in $O(|E| cdot dk_Q + |V| cdot em_Q)$, where $dk_Q$ and $em_Q$ are times needed to perform decrease key and extract minimum operations in set Q, respectively.

The simplest implementation of the Dijkstra's algorithm stores vertices of set Q in an ordinary linked list or array, and extract minimum from Q is simply a linear search through all vertices in Q. In this case, the running time is $O(|E| + |V|^2) = O(|V|^2)$.

For sparse graphs, that is, graphs with far fewer than $O(|V|^2)$ edges, Dijkstra's algorithm can be implemented more efficiently by storing the graph in the form of adjacency lists and using a self-balancing binary search tree, binary heap, pairing heap, or Fibonacci heap as a priority queue to implement extracting minimum efficiently. With a self-balancing binary search tree or binary heap, the algorithm requires $Theta((|E| + |V|) log |V|)$ time (which is dominated by $Theta( | E | log | V | )$, assuming the graph is connected). To avoid $O(|V|)$ look-up in decrease-key step on a vanilla binary heap, it is necessary to maintain a supplementary index mapping each vertex to the heap's index (and keep it up to date as priority queue Q changes), making it take only $O(log|V|)$ time instead. The Fibonacci heap improves this to $O(|E| + |V| log|V|)$.

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <map>
#define MAX 10000
using namespace std;

struct Node {
    int dist;
    int index;
    Node() {}
    Node(int i, int d) : index(i), dist(d) {}
};

ostream &operator<<(ostream& os, Node& node) {
    os << node.index << "(" << node.dist << ") "; 
    return os;
}

class Dijkstra{
    public:
        Dijkstra():n(0), capacity(100) {
            this->arr = new Node[capacity];
        }

        ~Dijkstra() {
            delete[] arr;
        }

        void insert(Node v) {
            if (n >= capacity) {
                Node* tmp = new Node[capacity << 1];
                memcpy(tmp, arr, sizeof(Node) * capacity);
                capacity <<= 1;
            }
            keyMap[v.index] = n;
            arr[n++] = v;
            shiftUp(n - 1);
        }

        void shiftDown(int st, int ed) {
            Node tmp = arr[st];
            while (st < ed) {
                int next = -1;
                int left = st * 2 + 1; // left child node 
                if (left < ed) next = left;
                else break;
                int right = st * 2 + 2;
                if (right < ed && arr[right].dist < arr[next].dist) next = right;
                if (arr[next].dist < arr[st].dist) {
                    keyMap[arr[next].index] = st;
                    arr[st] = arr[next];
                    st = next;
                } else break;
            }
            keyMap[tmp.index] = st;
            arr[st] = tmp;
        }

        void shiftUp(int ed) {
            Node tmp = arr[ed];
            while (ed > 0) {
                int parent = (ed - 1) / 2;
                if (arr[ed].dist < arr[parent].dist) {
                    keyMap[arr[parent].index] = ed;
                    arr[ed] = arr[parent];
                    ed = parent;
                } else break;
            }
            keyMap[tmp.index] = ed;
            arr[ed] = tmp;
        }

        void update(int pos, int v) {
            if (pos >= n) {
                arr[pos].dist = v;
            } else if (arr[pos].dist < v) {
                arr[pos].dist = v;
                shiftDown(pos, n);
            } else {
                arr[pos].dist = v;
                shiftUp(pos);
            }
        }

        bool empty() const {
            return n <= 0;
        }

        Node top() {
            if (empty()) return Node();
            return arr[0];
        }

        void pop() {
            if (empty()) return;
            keyMap[arr[n - 1].index] = 0;
            keyMap[arr[0].index] = n - 1;
            swap(arr[0], arr[n - 1]);
            shiftDown(0, --n);
        }

        void load(string filename) {
            ifstream in(filename.c_str());
            string line;
            getline(in, line);
            int n = atoi(line.c_str());

            while (adjList.size() < n && getline(in, line)) {
                vector<int> neigs;
                stringstream ss(line);
                int v = 0;
                while (ss >> v) {
                    neigs.push_back(v - 1);
                }
                adjList.push_back(neigs);
            }

            while (getline(in, line)) {
                vector<int> ws;
                stringstream ss(line);
                int w = 0;
                while (ss >> w) {
                    ws.push_back(w);
                }
                weights.push_back(ws);
            }

            for (int i = 0; i < adjList.size(); ++i) {
                for (int j = 0; j < adjList[i].size(); ++j) {
                    cout << adjList[i][j] << "(" << weights[i][j] << ") ";
                }
                cout << endl;
            }
        }

        // dijstra using binary heap, O((|V|+|E|)lg|V|)
        int run() {
            if (adjList.empty()) return 0;
            insert(Node(0, 0));
            for (int i = 1; i < adjList.size(); ++i) {
                insert(Node(i, MAX));
            }

            while (!empty()) {    
                Node nearest = top(); 
                pop(); // O(|V|lg|V|)

                for (int j = 0; j < adjList[nearest.index].size(); ++j) {
                    int d = nearest.dist + weights[nearest.index][j];
                    int neig = adjList[nearest.index][j];
                    if (d < arr[keyMap[neig]].dist) update(keyMap[neig], d); // O(|E|lg|V|)
                }
            }

            for (int i = 0; i < adjList.size(); ++i) {
                cout << arr[i] << " ";
            }
            cout << endl;
            return 0;
        }

    private:
        Node* arr;
        int n;
        int capacity;
        map<int, int> keyMap; // from graph index to arr index
        vector<vector<int> > adjList, weights;
};

int main()
{
    Dijkstra dij;
    dij.load("input.txt");
    dij.run();
    return 0;
}

input.txt:

6 
2 3 6
1 3 4
1 2 4 6
2 3 5
4 6
1 3 5
7 9 14
7 10 15
9 10 11 2
15 11 6
6 9
14 2 9

每一行是顶点个数；

前几行是邻接列表；后几行是对应的边的权重；

注意

dijkstra算法是不能处理负值边和负值环的。floyd可以。
有了负值那它的，整个算法所处理的结点的顺序就有问题了。负值会使后面处理的结点到起点的权值小于已经处理了的结点到起点的权值，该算法就不适用了。
比如：
1->2 2
1->3 100
3->2 -99
用dijkstra求1开始的单源最短路的话因该会得到1->2最短路是2的错误结果。