图之 最短路径 Dijkstra迪杰斯特拉算法

最短路径之Dijkstra迪杰斯特拉算法

描述

---

从某个源点到其余各顶点的最短路径

算法实现

---

图用带权邻接矩阵存储g.edges[][]

数组dist[]存放当前找到的从源点V0到每个终点的最短路径长度，其初态为：若有边则为图中直接路径权值，否则为无穷大

path[]中保存从v0到vi最短路径的前一个顶点，其初态为：若v0到vi有边则path[vi] = v0,否则path[vi] = -1

set[]为标记数组,其初态为: set[vo] = 1,其余元素均为0

代码

---

#include<stdio.h>
#include<iostream>
#include<malloc.h>
using namespace std;
#define maxsize 100
#define INFINITY 65535

typedef struct
{
    int edges[maxsize][maxsize];
    int n, e;
}MGraph;

void CreateMGraph(MGraph &G)
{
    int i, j;
    int v1, v2, w;
    cin >> G.n >> G.e;
    for (i = 1; i <= G.n; i++)
    {
        for (j = 1; j <= G.n; j++)
        {
            if (i == j)
            {
                G.edges[i][j] = 0;
            }
            else
            {
                G.edges[i][j] = INFINITY;
            }
        }
    }
    for (i = 1; i <= G.e; i++)
    {
        cin >> v1 >> v2 >> w;
        G.edges[v1][v2] = G.edges[v2][v1] = w;
    }
}

void print(MGraph G)
{
    int i, j;
    for (i = 1; i <= G.n; i++)
    {
        for (j = 1; j <= G.n; j++)
        {
            printf("%d ", G.edges[i][j]);
        }
        printf("\n");
    }
}

void Dijkstra(MGraph G, int v, int dist[], int path[])
{
    int set[maxsize];
    int min, i, j, u;
    for (i = 1; i <= G.n; i++)
    {
        dist[i] = G.edges[v][i];
        set[i] = 0;
        if (G.edges[v][i] < INFINITY)
        {
            path[i] = v;
        }
        else
        {
            path[i] = -1;
        }
    }
    set[v] = 1; //表示v已经加入最短路径
    path[v] = -1;  //v 到 v不需要求路径
    // 初始化结束
    // 关键操作开始
    for (i = 1; i <= G.n; i++)
    {
        min = INFINITY;
        for (j = 1; j <= G.n; j++)
        {
            if (set[j] == 0 && dist[j] < min)
            {
                u = j;
                min = dist[j];
            }
        }
        set[u] = 1;

        //这个循环以刚并入的顶点作为中间点，对所有通往剩余顶点的路径进行检查
        for (j = 1; j <= G.n; j++)
        {
            if (set[j] == 0 && dist[u] + G.edges[u][j] < dist[j])
            {
                dist[j] = dist[u] + G.edges[u][j];
                path[j] = u;
            }
        }
    }
}

//用栈打印path[]数组中保存的树即从源点到任何一个顶点最短路径所经过的所有顶点
void printPath(int path[], int a)
{
    int stack[maxsize], top = -1;
    while (path[a] != -1)
    {
        stack[++top] = a;
        a = path[a];
    }
    stack[++top] = a;
    while (top != -1)
    {
        printf("%d ", stack[top--]);
    }
    printf("\n");
}

int main()
{
    freopen("E:\input.txt", "r", stdin);
    MGraph G;
    int dist[maxsize], path[maxsize];
    Dijkstra(G, 1, dist, path);
    CreateMGraph(G);
    print(G);
    Dijkstra(G, 1, dist, path);
    printf("dis:\n");
    for (int i = 1; i <= G.n; i++)
    {
        printf("%d ", dist[i]);
    }
    printf("\n");
    printf("path:\n");
    for (int i = 1; i <= G.n; i++)
    {
        printf("%d ", path[i]);
    }
    printf("\n");
    printf("from 1 to 4:\n");
    //到第四个顶点经过的点
    printPath(path, 4);
    return 0;
}

Input

7 10
1 3 8
1 2 13
1 5 30
1 7 32
2 7 7
2 6 9
3 4 5
4 5 6
5 6 2
6 7 17

Output

0 13 8 65535 30 65535 32
13 0 65535 65535 65535 9 7
8 65535 0 5 65535 65535 65535
65535 65535 5 0 6 65535 65535
30 65535 65535 6 0 2 65535
65535 9 65535 65535 2 0 17
32 7 65535 65535 65535 17 0
dis:
0 13 8 13 19 21 20
path:
-1 1 1 3 4 5 2
from 1 to 4:
1 3 4

数据图例