狄克斯特拉算法求起一点到其余各点的最短路径代码C语言

### 回答1：
以下是Dijkstra算法的C语言实现代码，用于求解从起点到其余各点的最短路径：

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

#define INF 9999
#define MAX_VERTICES 1000

int graph[MAX_VERTICES][MAX_VERTICES];
int dist[MAX_VERTICES];
bool visited[MAX_VERTICES];
int num_vertices;

void dijkstra(int start)
{
    // 初始化距离数组和visited数组
    for (int i = 0; i < num_vertices; i++) {
        dist[i] = INF;
        visited[i] = false;
    }
    dist[start] = 0; // 起始点到自己的距离为0

    for (int i = 0; i < num_vertices - 1; i++) {
        int min_dist = INF;
        int min_vertex = -1;
        // 从未访问过的节点中找到距离最小的节点
        for (int j = 0; j < num_vertices; j++) {
            if (!visited[j] && dist[j] < min_dist) {
                min_dist = dist[j];
                min_vertex = j;
            }
        }
        if (min_vertex == -1) break;

        visited[min_vertex] = true;
        // 更新所有与该节点相邻的节点的距离
        for (int k = 0; k < num_vertices; k++) {
            if (graph[min_vertex][k] != INF) {
                int new_dist = dist[min_vertex] + graph[min_vertex][k];
                if (new_dist < dist[k]) {
                    dist[k] = new_dist;
                }
            }
        }
    }
}

int main()
{
    // 读入图
    scanf("%d", &num_vertices);
    for (int i = 0; i < num_vertices; i++) {
        for (int j = 0; j < num_vertices; j++) {
            scanf("%d", &graph[i][j]);
            if (graph[i][j] == -1) {
                graph[i][j] = INF;
            }
        }
    }

    int start;
    scanf("%d", &start);
    dijkstra(start);

    // 输出结果
    for (int i = 0; i < num_vertices; i++) {
        printf("Distance from %d to %d: %d\n", start, i, dist[i]);
    }

    return 0;
}

其中，`graph`是邻接矩阵，`dist`是距离数组，`visited`是访问标记数组，`num_vertices`是节点数。在主函数中读入图和起始节点，然后调用`dijkstra`函数计算最短路径，最后输出结果。

### 回答2：
狄克斯特拉算法用于求解一个节点到其他各节点的最短路径。下面是一个用C语言实现的狄克斯特拉算法的代码示例：

#include <stdio.h>
#define INF 9999
#define MAX_SIZE 100

void dijkstra(int graph[MAX_SIZE][MAX_SIZE], int n, int start){
    int distance[MAX_SIZE], visited[MAX_SIZE], min_distance, min_index, i, j;
    
    // 初始化所有节点的距离为无穷大，且未访问过
    for(i=0; i<n; i++){
        distance[i] = INF;
        visited[i] = 0;
    }
    
    // 设置起点到起点的距离为0
    distance[start] = 0;
    
    // 遍历所有节点
    for(i=0; i<n; i++){
        // 寻找当前未访问节点中距离最小的节点
        min_distance = INF;
        for(j=0; j<n; j++){
            if(!visited[j] && distance[j] < min_distance){
                min_distance = distance[j];
                min_index = j;
            }
        }
        
        // 标记该节点为已访问
        visited[min_index] = 1;
        
        // 更新与该节点相连的节点的距离
        for(j=0; j<n; j++){
            if(!visited[j] && graph[min_index][j] && distance[min_index]+graph[min_index][j] < distance[j]){
                distance[j] = distance[min_index] + graph[min_index][j];
            }
        }
    }
    
    // 打印最短路径
    printf("节点\t\t最短距离\n");
    for(i=0; i<n; i++){
        printf("%d\t\t%d\n", i, distance[i]);
    }
}

int main(){
    int n, start, i, j;
    
    printf("请输入节点数量：");
    scanf("%d", &n);
    
    int graph[MAX_SIZE][MAX_SIZE];
    printf("请输入邻接矩阵：\n");
    for(i=0; i<n; i++){
        for(j=0; j<n; j++){
            scanf("%d", &graph[i][j]);
        }
    }
    
    printf("请输入起点：");
    scanf("%d", &start);
    
    dijkstra(graph, n, start);
    
    return 0;
}

使用该代码，用户需要输入节点数量、邻接矩阵及起点，程序将计算并输出起点到每个节点的最短路径及距离。

### 回答3：
以下是使用C语言编写的狄克斯特拉算法代码，用于求解一个节点到其余各点的最短路径。

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

#define VERTICES 5

int minDistance(int dist[], int visited[])
{
    int min = INT_MAX;
    int min_index;

    for (int i = 0; i < VERTICES; i++)
    {
        if (visited[i] == 0 && dist[i] <= min)
        {
            min = dist[i];
            min_index = i;
        }
    }

    return min_index;
}

void dijkstra(int graph[VERTICES][VERTICES], int src)
{
    int dist[VERTICES];
    int visited[VERTICES];

    for (int i = 0; i < VERTICES; i++)
    {
        dist[i] = INT_MAX;
        visited[i] = 0;
    }

    dist[src] = 0;

    for (int count = 0; count < VERTICES - 1; count++)
    {
        int u = minDistance(dist, visited);
        visited[u] = 1;

        for (int v = 0; v < VERTICES; v++)
        {
            if (visited[v] == 0 && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])
            {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }

    printf("节点到各点的最短路径如下:\n");
    for(int i=0; i<VERTICES; i++){
        printf("节点 %d 到节点 %d 的最短距离为 %d\n", src, i, dist[i]);
    }
}

int main()
{
    int graph[VERTICES][VERTICES] = {
        {0, 4, 0, 5, 9},
        {4, 0, 3, 0, 2},
        {0, 3, 0, 6, 0},
        {5, 0, 6, 0, 7},
        {9, 2, 0, 7, 0}
    };

    int src = 0; // 指定起始节点

    dijkstra(graph, src);

    return 0;
}

在这个示例中，我们定义了一个5个节点的图，数组`graph`表示节点之间的连接，用0表示不可达的边。在主函数中，我们指定了起始节点`src`为0，并调用了`dijkstra`函数来求解起始节点到其余各点的最短路径。最后，打印出结果并返回。