根据实际情况，先建立交通网络图的存储结构。 )．求某个城市到达其余各城市的最短路径。 )．任一输入两个城市，要求求出他们之间的最短路径C语言

实现这个功能，可以使用 Dijkstra 算法，算法思路如下：

1. 创建一个数组 dist 存储源点到其它点的最短距离，初始化为无穷大。

2. 源点到自己的距离为 0。

3. 创建一个 visited 数组标记每个点是否已经加入最短路径中，初始化为 false。

4. 创建一个数组 path 存储源点到每个点的路径，path[i] 表示源点到 i 的路径。

5. 以源点为起点，将 dist[source] 设为 0，将 visited[source] 设为 true。

6. 对于源点相邻的每个点，计算源点到该点的距离，如果距离小于 dist[i]，则更新 dist[i] 和 path[i]。

7. 从所有未加入最短路径的点中选择一个距离最小的点，将其加入最短路径中。

8. 重复步骤 6 和 7，直到所有点都加入最短路径中。

9. 根据 path 数组求出任意两点之间的最短路径。

下面是求解任意两点之间的最短路径的代码实现：

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

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

// 邻接矩阵存储图
typedef struct {
    int n;             // 顶点数
    int e[MAX_VERTICES][MAX_VERTICES];  // 边权重
} Graph;

// Dijkstra 算法求最短路径
void dijkstra(Graph *g, int source, int dist[], int path[]) {
    int i, j, u;
    int min;
    int visited[MAX_VERTICES]; // 标记是否已加入最短路径

    // 初始化 dist[], visited[], path[]
    for (i = 0; i < g->n; i++) {
        dist[i] = g->e[source][i];
        visited[i] = 0;
        if (dist[i] < INF) {
            path[i] = source;
        } else {
            path[i] = -1;
        }
    }
    dist[source] = 0;
    visited[source] = 1;

    // 找到离源点最近的点
    for (i = 1; i < g->n; i++) {
        min = INF;
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && dist[j] < min) {
                u = j;
                min = dist[j];
            }
        }
        visited[u] = 1;

        // 更新 dist[], path[]
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && g->e[u][j] < INF) {
                if (dist[u] + g->e[u][j] < dist[j]) {
                    dist[j] = dist[u] + g->e[u][j];
                    path[j] = u;
                }
            }
        }
    }
}

// 输出从源点到目标点的路径
void printPath(int path[], int target) {
    if (path[target] == -1) {
        printf("No path to %d\n", target);
    } else {
        int p = target;
        printf("%d", p);
        while (path[p] != -1) {
            printf(" <- %d", path[p]);
            p = path[p];
        }
        printf("\n");
    }
}

int main() {
    Graph g = {
        6,
        {
            {0, 2, INF, 1, INF, INF},
            {INF, 0, INF, 3, 10, INF},
            {4, INF, 0, INF, INF, 5},
            {INF, INF, 2, 0, 2, 8},
            {INF, INF, INF, INF, 0, INF},
            {INF, INF, INF, INF, 6, 0},
        }
    };

    int dist[MAX_VERTICES]; // 最短距离
    int path[MAX_VERTICES]; // 最短路径

    int source = 0; // 源点
    int target = 3; // 目标点

    dijkstra(&g, source, dist, path);
    printf("Shortest path from %d to %d is %d\n", source, target, dist[target]);
    printPath(path, target);

    return 0;
}

以上代码实现了一个简单的 Dijkstra 算法，可以求解任意两点之间的最短路径。需要注意的是，这里的图使用邻接矩阵存储，如果使用邻接表存储，需要稍微修改一下代码。