使用c输入有向图的相关信息，使用Dijkstra算法，求源点到其余顶点的最短路径长度。 注意： （1）使用邻接矩阵存储图的信息 （2）按路径长度递增的次序产生最短路径并输出 若源点到某顶点无路径，则放在最后输出。如：0到1无路径。 输入说明： 第一行输入有向图的顶点数、边数 第二行输入各顶点的值 接下来的若干行，输入各边的信息。输入格式：起始顶点 终止顶点 权值 最后输入源点的值 输出说明： 输出源点到其余顶点的最短路径长度（其中的冒号为中文全角标点符号） 输入样例： 6 8 0 1 2 3 4 5 0 2 10 0 4 30 0 5 100 1 2 5 2 3 50 3 5 10 4 3 20 4 5 60 0 输出样例： 0到2的最短路径长度：10 0到4的最短路径长度：30 0到3的最短路径长度：50 0到5的最短路径长度：60 0到1无路径】

以下是C语言实现Dijkstra算法求解最短路径的代码，可以根据题目要求进行适当的修改：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 100 // 最大顶点数
#define INFINITY 65535 // 定义正无穷，表示两点之间没有路径

typedef struct {
    int vexs[MAX_VERTEX_NUM]; // 存储顶点的数组
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边的邻接矩阵
    int vexnum, arcnum; // 顶点数和边数
} Graph;

// 初始化有向图
void InitGraph(Graph *G) {
    int i, j;
    printf("请输入有向图的顶点数和边数：");
    scanf("%d%d", &G->vexnum, &G->arcnum);
    printf("请输入%d个顶点的值：\n", G->vexnum);
    for (i = 0; i < G->vexnum; i++) {
        scanf("%d", &G->vexs[i]);
    }
    for (i = 0; i < G->vexnum; i++) {
        for (j = 0; j < G->vexnum; j++) {
            G->arcs[i][j] = INFINITY; // 初始化邻接矩阵
        }
    }
    printf("请输入%d条边的信息：\n", G->arcnum);
    for (i = 0; i < G->arcnum; i++) {
        int v1, v2, weight;
        scanf("%d%d%d", &v1, &v2, &weight);
        G->arcs[v1][v2] = weight;
    }
}

// Dijkstra算法求解最短路径
void Dijkstra(Graph G, int v0, int *dist, int *path) {
    int i, j;
    int S[MAX_VERTEX_NUM]; // 存储已确定最短路径的顶点集合
    for (i = 0; i < G.vexnum; i++) {
        dist[i] = G.arcs[v0][i]; // 初始化dist数组
        S[i] = 0; // 初始化S数组
        if (G.arcs[v0][i] < INFINITY) {
            path[i] = v0; // 如果v0和i之间有路径，则把i的前驱顶点设为v0
        } else {
            path[i] = -1; // 如果v0和i之间没有路径，则把i的前驱顶点设为-1
        }
    }
    dist[v0] = 0; // v0到v0的距离为0
    S[v0] = 1; // 把v0加入到S中
    for (i = 1; i < G.vexnum; i++) { // 依次确定剩余的n-1个顶点的最短路径
        int min = INFINITY;
        int u = v0;
        for (j = 0; j < G.vexnum; j++) {
            if (S[j] == 0 && dist[j] < min) { // 找到距离v0最近的顶点u
                min = dist[j];
                u = j;
            }
        }
        S[u] = 1; // 把u加入到S中
        for (j = 0; j < G.vexnum; j++) { // 更新dist数组和path数组
            if (S[j] == 0 && G.arcs[u][j] < INFINITY && dist[u] + G.arcs[u][j] < dist[j]) {
                dist[j] = dist[u] + G.arcs[u][j];
                path[j] = u;
            }
        }
    }
}

int main() {
    Graph G;
    int i;
    int dist[MAX_VERTEX_NUM]; // 存储源点到各顶点的最短路径长度
    int path[MAX_VERTEX_NUM]; // 存储源点到各顶点的最短路径中各顶点的前驱顶点
    InitGraph(&G);
    printf("请输入源点的值：");
    int v0;
    scanf("%d", &v0);
    Dijkstra(G, v0, dist, path);
    for (i = 0; i < G.vexnum; i++) {
        if (dist[i] == INFINITY) {
            printf("%d到%d无路径\n", v0, G.vexs[i]); // 源点到某顶点无路径
        } else if (dist[i] == 0) {
            printf("%d到%d的最短路径长度：0\n", v0, G.vexs[i]); // 源点到自身的距离为0
        } else {
            printf("%d到%d的最短路径长度：%d，路径为：", v0, G.vexs[i], dist[i]);
            int j = i;
            while (path[j] != v0) { // 从终点往前找路径
                printf("%d->", G.vexs[path[j]]);
                j = path[j];
            }
            printf("%d->%d\n", G.vexs[v0], G.vexs[i]); // 输出起点到终点的路径
        }
    }
    return 0;
}