用c语言涉及一个设计一个城市交通咨询模拟系统，利用该系统实现至少两种最优决策：最短路程到达、最省时到达等线路规划的c语言代码

以下是一个简单的城市交通咨询模拟系统的 C 语言代码示例，实现了最短路程到达和最省时到达两种线路规划：

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

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

typedef struct {
    int weight[MAX_VERTICES][MAX_VERTICES]; // 存储图的邻接矩阵
    int n; // 顶点数
} Graph;

// 初始化图
void initGraph(Graph *g, int n) {
    int i, j;
    g->n = n;
    for (i = 0; i < g->n; i++) {
        for (j = 0; j < g->n; j++) {
            g->weight[i][j] = INF;
        }
    }
}

// 添加边
void addEdge(Graph *g, int u, int v, int w) {
    g->weight[u][v] = w;
}

// 最短路程到达
void shortestPath(Graph *g, int start, int end) {
    int dist[MAX_VERTICES]; // 存储起点到每个点的最短距离
    int prev[MAX_VERTICES]; // 存储最短路径上每个点的前一个点
    int visited[MAX_VERTICES]; // 标记每个点是否已访问
    int i, j, u, min;
    // 初始化
    for (i = 0; i < g->n; i++) {
        dist[i] = g->weight[start][i];
        prev[i] = start;
        visited[i] = 0;
    }
    dist[start] = 0;
    visited[start] = 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;
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && dist[j] > dist[u] + g->weight[u][j]) {
                dist[j] = dist[u] + g->weight[u][j];
                prev[j] = u;
            }
        }
    }
    // 输出最短路径
    printf("Shortest path from %d to %d: %d\n", start, end, dist[end]);
    printf("Path: %d", end);
    i = end;
    while (i != start) {
        i = prev[i];
        printf(" <- %d", i);
    }
    printf("\n");
}

// 最省时到达
void fastestPath(Graph *g, int start, int end) {
    int dist[MAX_VERTICES]; // 存储起点到每个点的最短时间
    int prev[MAX_VERTICES]; // 存储最短时间路径上每个点的前一个点
    int visited[MAX_VERTICES]; // 标记每个点是否已访问
    int time[MAX_VERTICES]; // 存储起点到每个点的最短时间
    int i, j, u, min;
    // 初始化
    for (i = 0; i < g->n; i++) {
        dist[i] = g->weight[start][i];
        prev[i] = start;
        visited[i] = 0;
        time[i] = dist[i]; // 初始时间等于距离
    }
    dist[start] = 0;
    visited[start] = 1;
    // 计算最短时间路径
    for (i = 1; i < g->n; i++) {
        min = INF;
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && time[j] < min) {
                u = j;
                min = time[j];
            }
        }
        visited[u] = 1;
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && time[j] > time[u] + g->weight[u][j]) {
                dist[j] = dist[u] + g->weight[u][j];
                time[j] = time[u] + g->weight[u][j] * 2; // 时间等于距离的两倍
                prev[j] = u;
            }
        }
    }
    // 输出最短时间路径
    printf("Fastest path from %d to %d: %d\n", start, end, time[end]);
    printf("Path: %d", end);
    i = end;
    while (i != start) {
        i = prev[i];
        printf(" <- %d", i);
    }
    printf("\n");
}

int main() {
    Graph g;
    int i, n, m, u, v, w, start, end;
    printf("Enter the number of vertices and edges:\n");
    scanf("%d%d", &n, &m);
    initGraph(&g, n);
    printf("Enter the edges (u v w):\n");
    for (i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        addEdge(&g, u, v, w);
    }
    printf("Enter the start and end points:\n");
    scanf("%d%d", &start, &end);
    shortestPath(&g, start, end);
    fastestPath(&g, start, end);
    return 0;
}

这段代码实现了一个简单的图的邻接矩阵存储方式，并使用 Dijkstra 算法和 A* 算法分别计算了最短路径和最短时间路径。可以根据需要进行修改和优化。