C语言使用邻接矩阵储存结构构建有向带权图并给出相应的狄克斯特拉算法正确输出每条最简路径

好的，让我来回答你的问题。

如果要输出每条最短路径，可以在 `dijkstra` 函数中增加一个数组 `path_list`，用来存储每个顶点的最短路径。在每次更新某个顶点的最短距离时，我们将该顶点的最短路径存入 `path_list` 数组中。最后，我们可以通过 `path_list` 数组来输出每条最短路径。

下面是修改后的代码：

#include <stdio.h>
#include <stdbool.h>

#define MAX_VERTICES 100 // 最大顶点数
#define INF 1000000000 // 无穷大

int graph[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵
int dist[MAX_VERTICES]; // 存储起点到各顶点的最短距离
bool visited[MAX_VERTICES]; // 标记各顶点是否已被访问
int path[MAX_VERTICES]; // 存储最短路径
int path_list[MAX_VERTICES][MAX_VERTICES]; // 存储每个顶点的最短路径
int n; // 顶点数

// Dijkstra算法
void dijkstra(int start, int end) {
    // 初始化
    for (int i = 0; i < n; i++) {
        dist[i] = INF;
        visited[i] = false;
    }
    dist[start] = 0;
    path[start] = -1;
    
    // 求最短路径
    for (int i = 0; i < n; i++) {
        // 选择未访问的距离起点最近的顶点
        int min_dist = INF;
        int u;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < min_dist) {
                min_dist = dist[j];
                u = j;
            }
        }
        visited[u] = true;
        
        // 更新与该顶点相邻的未访问顶点的距离
        for (int v = 0; v < n; v++) {
            if (!visited[v] && graph[u][v] != INF) {
                if (dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                    path[v] = u;
                    
                    // 存储每个顶点的最短路径
                    int p = v;
                    int k = 0;
                    while (p != -1) {
                        path_list[v][k++] = p;
                        p = path[p];
                    }
                    for (int i = 0; i < k / 2; i++) {
                        int temp = path_list[v][i];
                        path_list[v][i] = path_list[v][k-1-i];
                        path_list[v][k-1-i] = temp;
                    }
                }
            }
        }
    }
    
    // 输出每条最短路径
    for (int i = 0; i < n; i++) {
        if (dist[i] != INF) {
            printf("起点到顶点%d的最短距离为：%d，最短路径为：", i, dist[i]);
            for (int j = 0; j < n; j++) {
                if (path_list[i][j] == -1) {
                    break;
                }
                printf("%d ", path_list[i][j]);
            }
            printf("\n");
        }
    }
}

int main() {
    // 读入顶点数和边数
    int m;
    printf("请输入顶点数和边数：");
    scanf("%d %d", &n, &m);
    
    // 初始化邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                graph[i][j] = 0;
            } else {
                graph[i][j] = INF;
            }
        }
    }
    
    // 读入边的信息，构建邻接矩阵
    printf("请输入每条边的起点、终点、边权：\n");
    for (int i = 0; i < m; i++) {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        graph[u][v] = w;
    }
    
    // 读入起点和终点
    int start, end;
    printf("请输入起点和终点：");
    scanf("%d %d", &start, &end);
    
    // 使用Dijkstra算法求最短路径
    dijkstra(start, end);
    
    return 0;
}

在这个代码中，我们使用了一个二维数组 `path_list` 来存储每个顶点的最短路径。在更新某个顶点的最短路径时，我们将该顶点的最短路径存入 `path_list` 数组中。最后，我们可以通过遍历 `path_list` 数组来输出每条最短路径。

如果您有任何疑问，请随时问我。