不愧是荣获图灵奖的解法，沿用至今，简直绝了

Dijkstra算法是一种用于在加权图中找到最短路径的算法，由荷兰计算机科学家艾兹赫尔·戴克斯特拉（Edsger W. Dijkstra）在1956年提出，并在1959年发表。该算法可以找到一个顶点到图中所有其他顶点的最短路径，也可以找到两个顶点之间的最短路径。

Dijkstra算法的基本思想是贪心算法，它按照路径长度的递增次序来逐步确定最短路径。

精妙至极，不算复杂，但是  牛逼！牛逼！还是牛逼！

下面根据离散数学的一道题写出来的实现代码：

#include <stdio.h>
#include <limits.h>

// 定义顶点的最大数量
#define MAX_VERTICES 5

// 定义无穷大的值，用于初始化距离数组
#define INFINITY INT_MAX

// 定义图的结构体
typedef struct {
    int numVertices; // 顶点的数量
    int distances[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵，表示图的权重
} Graph;

// 初始化图
void initGraph(Graph *g) {
    g->numVertices = MAX_VERTICES;
    // 初始化邻接矩阵，0表示没有边，其他值表示边的权重
    for (int i = 0; i < g->numVertices; i++) {
        for (int j = 0; j < g->numVertices; j++) {
            if (i == j) {
                g->distances[i][j] = 0; // 自环权重为0
            } else {
                g->distances[i][j] = INFINITY; // 未连接的顶点权重为无穷大
            }
        }
    }
    // 根据题目中的图，设置具体的权重
    g->distances[0][1] = 10;
    g->distances[0][4] = 100;
    g->distances[1][2] = 50;
    g->distances[1][3] = 30;
    g->distances[2][3] = 20;
    g->distances[2][4] = 30;
    g->distances[3][4] = 60;
}

// 打印图的邻接矩阵
void printGraph(Graph *g) {
    for (int i = 0; i < g->numVertices; i++) {
        for (int j = 0; j < g->numVertices; j++) {
            if (g->distances[i][j] == INFINITY) {
                printf("INF\t");
            } else {
                printf("%d\t", g->distances[i][j]);
            }
        }
        printf("\n");
    }
}

// Dijkstra算法实现
void dijkstra(Graph *g, int startVertex) {
    int dist[MAX_VERTICES]; // 存储从起点到每个顶点的最短距离
    int visited[MAX_VERTICES] = {0}; // 标记顶点是否已经访问过

    // 初始化距离数组
    for (int i = 0; i < g->numVertices; i++) {
        dist[i] = g->distances[startVertex][i];
    }
    dist[startVertex] = 0; // 起点到自己的距离为0

    // 对每个顶点执行Dijkstra算法
    for (int i = 0; i < g->numVertices - 1; i++) {
        // 找到未访问的顶点中距离最小的顶点
        int minDistance = INFINITY;
        int minIndex = -1;
        for (int j = 0; j < g->numVertices; j++) {
            if (!visited[j] && dist[j] < minDistance) {
                minDistance = dist[j];
                minIndex = j;
            }
        }

        // 标记这个顶点为已访问
        visited[minIndex] = 1;

        // 更新相邻顶点的距离
        for (int j = 0; j < g->numVertices; j++) {
            if (!visited[j] && g->distances[minIndex][j] != INFINITY &&
                dist[minIndex] + g->distances[minIndex][j] < dist[j]) {
                dist[j] = dist[minIndex] + g->distances[minIndex][j];
            }
        }
    }

    // 打印从起点到每个顶点的最短距离
    printf("从顶点%d到其他顶点的最短距离:\n", startVertex + 1);
    for (int i = 0; i < g->numVertices; i++) {
        printf("顶点%d: %d\n", i + 1, dist[i]);
    }
}

int main() {
    Graph g;
    initGraph(&g); // 初始化图
    printGraph(&g); // 打印图的邻接矩阵
    dijkstra(&g, 0); // 执行Dijkstra算法，从顶点1开始
    return 0;
}

初始化：

void initGraph(Graph *g) {
    g->numVertices = MAX_VERTICES;
    // 初始化邻接矩阵，0表示没有边，其他值表示边的权重
    for (int i = 0; i < g->numVertices; i++) {
        for (int j = 0; j < g->numVertices; j++) {
            if (i == j) {
                g->distances[i][j] = 0; // 自环权重为0
            } else {
                g->distances[i][j] = INFINITY; // 未连接的顶点权重为无穷大
            }
        }
    }
    // 根据题目中的图，设置具体的权重
    g->distances[0][1] = 10;
    g->distances[0][4] = 100;
    g->distances[1][2] = 50;
    g->distances[1][3] = 30;
    g->distances[2][3] = 20;
    g->distances[2][4] = 30;
    g->distances[3][4] = 60;
}

先打印原型：

void printGraph(Graph *g) {
    for (int i = 0; i < g->numVertices; i++) {
        for (int j = 0; j < g->numVertices; j++) {
            if (g->distances[i][j] == INFINITY) {
                printf("INF\t");
            } else {
                printf("%d\t", g->distances[i][j]);
            }
        }
        printf("\n");
    }
}

开始操作：

void dijkstra(Graph *g, int startVertex) {
    int dist[MAX_VERTICES]; // 存储从起点到每个顶点的最短距离
    int visited[MAX_VERTICES] = {0}; // 标记顶点是否已经访问过

    // 初始化距离数组
    for (int i = 0; i < g->numVertices; i++) {
        dist[i] = g->distances[startVertex][i];
    }
    dist[startVertex] = 0; // 起点到自己的距离为0

    // 对每个顶点执行Dijkstra算法
    for (int i = 0; i < g->numVertices - 1; i++) {
        // 找到未访问的顶点中距离最小的顶点
        int minDistance = INFINITY;
        int minIndex = -1;
        for (int j = 0; j < g->numVertices; j++) {
            if (!visited[j] && dist[j] < minDistance) {
                minDistance = dist[j];
                minIndex = j;
            }
        }

        // 标记这个顶点为已访问
        visited[minIndex] = 1;

        // 更新相邻顶点的距离
        for (int j = 0; j < g->numVertices; j++) {
            if (!visited[j] && g->distances[minIndex][j] != INFINITY &&
                dist[minIndex] + g->distances[minIndex][j] < dist[j]) {
                dist[j] = dist[minIndex] + g->distances[minIndex][j];
            }
        }
    }

    // 打印从起点到每个顶点的最短距离
    printf("从顶点%d到其他顶点的最短距离:\n", startVertex + 1);
    for (int i = 0; i < g->numVertices; i++) {
        printf("顶点%d: %d\n", i + 1, dist[i]);
    }
}