【数据结构】最短路径

在图论中，最短路径问题是一个经典且重要的问题，它用于寻找两个顶点之间距离最短的路径。本文将详细介绍两种常用的最短路径算法——Dijkstra算法和Bellman-Ford算法的原理，并提供C语言代码示例，演示它们的实现方式及应用场景。

一、Dijkstra算法

Dijkstra算法是一种贪心算法，用于求解带有非负权值的加权图的单源最短路径问题。它的基本思想是，从起始顶点开始，逐步扩展已经找到的最短路径集合，直到找到从起始顶点到所有其他顶点的最短路径。

理论知识：

初始化： 将起始顶点到所有其他顶点的距离初始化为无穷大，起始顶点到自身的距离初始化为0。
迭代过程： 每次从尚未访问的顶点中选择距离最短的顶点，更新与其相邻的顶点的距离。
终止条件： 所有顶点都被访问完毕，或者所有顶点都已经加入到最短路径集合中。

C语言实现：

下面是用C语言实现Dijkstra算法的示例代码：

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

#define V 5 // 图中顶点数

int minDistance(int dist[], int sptSet[]) {
    int min = INT_MAX, min_index;
    for (int v = 0; v < V; v++) {
        if (sptSet[v] == 0 && dist[v] < min) {
            min = dist[v];
            min_index = v;
        }
    }
    return min_index;
}

void printSolution(int dist[]) {
    printf("顶点到源点的最短路径距离：\n");
    for (int i = 0; i < V; i++) {
        printf("%d -> %d\n", i, dist[i]);
    }
}

void dijkstra(int graph[V][V], int src) {
    int dist[V];
    int sptSet[V];

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

    dist[src] = 0;

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

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

    printSolution(dist);
}

int main() {
    int graph[V][V] = {
        {0, 4, 0, 0, 0},
        {4, 0, 8, 0, 0},
        {0, 8, 0, 7, 0},
        {0, 0, 7, 0, 9},
        {0, 0, 0, 9, 0}
    };

    dijkstra(graph, 0);

    return 0;
}

二、Bellman-Ford算法

Bellman-Ford算法是一种用于求解带有负权值的加权图的单源最短路径问题的动态规划算法。它的基本思想是，从源顶点开始，逐步扩展已经找到的最短路径集合，直到找到从源顶点到所有其他顶点的最短路径。

理论知识：

初始化： 将源顶点到所有其他顶点的距离初始化为无穷大，源顶点到自身的距离初始化为0。
迭代过程： 进行 V-1 次松弛操作，即尝试通过中间顶点更新顶点间的距离。

检测负权环： 再进行一次松弛操作，如果仍然可以更新距离，则图中存在负权环。

C语言实现：

下面是用C语言实现Bellman-Ford算法的示例代码：

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

#define V 5 // 图中顶点数
#define E 8 // 图中边数

typedef struct {
    int src, dest, weight;
} Edge;

void printSolution(int dist[]) {
    printf("顶点到源点的最短路径距离：\n");
    for (int i = 0; i < V; i++) {
        printf("%d -> %d\n", i, dist[i]);
    }
}

void bellmanFord(Edge edges[], int src) {
    int dist[V];

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

    dist[src] = 0;

    for (int i = 0; i < V - 1; i++) {
        for (int j = 0; j < E; j++) {
            int u = edges[j].src;
            int v = edges[j].dest;
            int weight = edges[j].weight;
            if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
            }
        }
    }

    for (int i = 0; i < E; i++) {
        int u = edges[i].src;
        int v = edges[i].dest;
        int weight = edges[i].weight;
        if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
            printf("图中存在负权环\n");
            return;
        }
    }

    printSolution(dist);
}

int main() {
    Edge edges[E] = {
        {0, 1, -1}, {0, 2, 4}, {1, 2, 3}, {1, 3, 2},
        {1, 4, 2}, {3, 2, 5}, {3, 1, 1}, {4, 3, -3}
    };

    bellmanFord(edges, 0);

    return 0;
}