单源最短路径

本文章使用狄克斯特拉算法，该算法不可以应用于包含负权值的图。具有负权值的图可以套用贝尔曼-福特算法或弗洛伊德算法来处理

输入：第一行输入G的顶点数n。接下来n行按如下格式输入各顶点u的邻接表。

　　　u k v1 c1 v2 c2 ... vk ck

　　　G中的各顶点编号分别为0至n-1。u代表顶点的编号，k代表u的出度。vi（i = 1, 2, ... , k)代表与u相邻顶点的编号，ci代表u到vi的有向边的权值。

输出：按顺序输出个顶点编号v及距离d[v]，相邻数据间用1个空格隔开。

#include<iostream>
using namespace std;

static const int MAX = 100;
static const int INFTY = (1<<21);
static const int WHITE = 0;
static const int GRAY = 1;//代表预选 
static const int BLACK = 2;//代表入选 

int n, M[MAX][MAX];
//狄克斯特拉
void dijkstra() {
    int minv;
    /*
    1.d[n]用于记录起点s到v的最短路径成本 
    2.p[n]用于记录顶点v在最短路径树中的父节点 
    */
    int d[MAX], color[MAX], p[MAX];
    
    //初始化
    for(int i = 0; i < n; i++) {
        d[i] = INFTY;
        p[i] = -1;
        color[i] = WHITE;
    } 
    d[0] = 0;
    color[0] = GRAY;
    
    while(1) {
        minv = INFTY;
        int u = -1;
        for(int i = 0; i < n; i++) {
            if(minv > d[i] && color[i] != BLACK) {
                u = i;
                minv = d[i];
            }
        }
        //遍历结束则退出循环 
        if(u == -1)    break;
        color[u] = BLACK;
        
        for(int v = 0; v < n; v++) {
            if(color[v] != BLACK && M[u][v] != INFTY) {
                if(d[v] > d[u] + M[u][v]) {
                    d[v] = d[u] + M[u][v];
                    color[v] = GRAY;
                    p[v] = u;
                }
            }
        }
    }
    
    for(int i = 0; i < n; i++) {
        cout << i << " " << (d[i] == INFTY? -1 : d[i]) << endl;
    }
}

int main() {
    cin >> n;
    //初始化 
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            M[i][j] = INFTY;
        }
    }
    
    int k, c, u, v;
    for(int i = 0; i < n; i++) {
        cin >> u >> k;
        for(int j = 0; j < k; j++) {
            cin >> v >> c;
            M[u][v] = c;
        }
    }
    
    dijkstra();
    
    return 0;
} 

/*
5
0 3 2 3 3 1 1 2
1 2 0 2 3 4
2 3 0 3 3 1 4 1
3 4 2 1 0 1 1 4 4 3
4 2 2 1 3 3
*/