Dijkstra算法：找单源点最短路径

Dijkstra算法：        

        把所有结点划分成连个集合V和V-S、S中是已经找到最短距离的结点集合、V-S是暂时还没有找到最短距离的结合，初始时S中只有源点，每次在V-S中找出距离S中距离最小的结点t，将其加入S集合，同时更新V-S中结点到S的最短距离，直到V-S为空，得到图中所有结点距离源点的最短距离。

1、保存一个带权有向图

        用邻接矩阵存储一个有向图，若有u到v有边，则edge[u][v]记录权值，否则将其记录为无穷大

class Graph
{
public:
    int edge[maxn][maxn];
    int vex_num, edge_num;
};


void CreateGraph(Graph& g)
{
    memset(g.edge, max_value, sizeof(g.edge));
    int u, v, w;
    cout << "请输入结点数：" << endl;
    cin >> g.vex_num;
    cout << "请输入边数：" << endl;
    cin >> g.edge_num;
    cout << "请依次输入每条边边的两个顶点和权值：" << endl;
    for (int i = 1; i <= g.edge_num; i++)
    {
        cin >> u >> v >> w;
        g.edge[u][v] = w;
    }
}

2、初始化

        有两个集合S、V-S，其中S中是已经找到最短距离的结点集合、V-S是暂时还没有找到最短距离的结合，初始时S中只有源点。dist数组记录每个结点到源点的最短路径，若结点和源点在图中没有边，记为无穷大；p数组记录最短路径上的前驱，若与源点不邻接，前驱记为-1。

for (int i = 1; i <= g.vex_num; i++)   
    {
        dist[i] = g.edge[u][i];
        if (dist[i] == max_value)
        {
            p[i] = -1;
        }
        else
        {
            p[i] = u;
        }
    }
    dist[u] = 0;
    ins[u] = true;

 3、找最小

找出V-S集合中距离S中结点距离最小的结点，并记录结点号和权值

int temp = max_value, t = u;   
        for (int j = 1; j <= g.vex_num; j++)
        {
            if (!ins[j] && (dist[j] < temp))
            {
                temp = dist[j];
                t = j;
            }
        }

4、判结束

如果V-S集合为空，算法结束；为空的标志：找不到V-S集合中距离S中结点距离最小的结点

if (t == u)
{
       return;
}

5、加入S

将找最小中找到的结点t加入到S中，更新S；

ins[t] = true;

6、借东风

已经找到了t的最短距离，查看是否能根据此距离更新在V-S中结点的最短路径（只有与t邻接才有机会更新）

 for (int j = 1; j <= g.vex_num; j++)
        {
            if (!ins[j] && g.edge[t][j] < max_value)   //有t->j，且j不在S中
            {
                if (dist[j] > (dist[t] + g.edge[t][j]))
                {
                    dist[j] = dist[t] + g.edge[t][j];
                    p[j] = t;
                }
            }
        }

整体代码实现：

#include <iostream>
using namespace std;
#define maxn 100
#define max_value 0x3f3f3f3f

int dist[maxn], p[maxn];
bool ins[maxn];

class Graph
{
public:
    int edge[maxn][maxn];
    int vex_num, edge_num;
};


void CreateGraph(Graph& g)
{
    memset(g.edge, max_value, sizeof(g.edge));
    int u, v, w;
    cout << "请输入结点数：" << endl;
    cin >> g.vex_num;
    cout << "请输入边数：" << endl;
    cin >> g.edge_num;
    cout << "请依次输入每条边边的两个顶点和权值：" << endl;
    for (int i = 1; i <= g.edge_num; i++)
    {
        cin >> u >> v >> w;
        g.edge[u][v] = w;
    }
}

void Dijkstra(Graph g, int u)
{
    //初始化
    for (int i = 1; i <= g.vex_num; i++)   
    {
        dist[i] = g.edge[u][i];
        if (dist[i] == max_value)
        {
            p[i] = -1;
        }
        else
        {
            p[i] = u;
        }
    }
    dist[u] = 0;
    ins[u] = true;
    for (int i = 1; i < g.vex_num; i++)
    {
        //找最小
        int temp = max_value, t = u;   //记录V到V-S中结点的最短距离和结点号
        for (int j = 1; j <= g.vex_num; j++)
        {
            if (!ins[j] && (dist[j] < temp))
            {
                temp = dist[j];
                t = j;
            }
        }
        //判结束
        if (t == u)
        {
            return;
        }
        //加入S集合
        ins[t] = true;
        //借东风
        for (int j = 1; j <= g.vex_num; j++)
        {
            if (!ins[j] && g.edge[t][j] < max_value)   //有t->j，且j不在S中
            {
                if (dist[j] > (dist[t] + g.edge[t][j]))
                {
                    dist[j] = dist[t] + g.edge[t][j];
                    p[j] = t;
                }
            }
        }
    }
}

int main()
{
    Graph g;
    CreateGraph(g);
    Dijkstra(g, 1);
    for (int i = 1; i <= g.vex_num; i++)
    {
        cout << dist[i] << " ";
    }
    cout << endl;

    return 0;
}