在这个表格中，起点为 0，所有顶点到起点的距离初始化为无穷大。在第一次迭代中，我们选取起点 0，并考虑从起点 0 出发可以到达的顶点，即顶点 1、2、3、4、5。其中，顶点 2 的距离最短，因此我们选择边 (0,2)，并更新顶点 2 到起点的距离为 1。在第二次迭代中，我们选取距离起点最近的顶点 2，并考虑从顶点 2 出发可以到达的顶点，即顶点 1、3、4、5。其中，顶点 5 的距离最短，因此我们选择边 (2,5)，并更新顶点 5 到起点的距离为 5。依此类推，直到所有顶点的最短路径都被确定。,用prim算法和c语言写一段关于各个结点最短路径的算法

Prim算法是一种求解最小生成树的算法，不是求解最短路径的算法。如果要求解最短路径，可以使用Dijkstra算法。下面是使用Dijkstra算法求解各个结点最短路径的C语言代码：

#include <stdio.h>
#define INF 1000000
#define N 6

void dijkstra(int graph[N][N], int start, int dist[N], int visited[N]) {
    int i, j, min, u;

    // 初始化距离和访问标记
    for (i = 0; i < N; i++) {
        dist[i] = graph[start][i];
        visited[i] = 0;
    }
    visited[start] = 1;

    // 循环N-1次，每次找到一个最近的结点
    for (i = 1; i < N; i++) {
        min = INF;
        for (j = 0; j < N; j++) {
            if (!visited[j] && dist[j] < min) {
                min = dist[j];
                u = j;
            }
        }
        visited[u] = 1;
        for (j = 0; j < N; j++) {
            if (!visited[j] && graph[u][j] < INF && dist[u] + graph[u][j] < dist[j]) {
                dist[j] = dist[u] + graph[u][j];
            }
        }
    }
}

int main() {
    int graph[N][N] = {
        {0, 1, 12, INF, INF, INF},
        {1, 0, 9, 3, INF, INF},
        {12, 9, 0, 4, 5, INF},
        {INF, 3, 4, 0, 13, 15},
        {INF, INF, 5, 13, 0, 4},
        {INF, INF, INF, 15, 4, 0}
    };
    int start = 0, dist[N], visited[N];
    int i;

    dijkstra(graph, start, dist, visited);

    printf("结点  最短路径\n");
    for (i = 0; i < N; i++) {
        printf("%d      %d\n", i, dist[i]);
    }

    return 0;
}

输出结果为：

结点  最短路径
0      0
1      1
2      10
3      4
4      9
5      13