【智能算法】图搜索算法-CSDN博客

深度优先搜索（DFS）是一种广泛应用于计算机科学领域的算法，它主要用于遍历或搜索树形结构或图结构中的节点。其核心思想是尽可能深入地沿着一条路径进行探索，直到这条路径的末端，然后回溯到上一个分叉点，继续探索其他路径。这种搜索策略类似于我们在迷宫中寻找出口的过程，总是尽可能地深入探索，直到无路可走，再返回上一个岔路口，尝试其他可能的路径。

在实现深度优先搜索时，通常有两种方法：递归和迭代。递归方法利用函数调用自身的特性，通过递归调用来遍历每一个分支。这种方法代码简洁，易于理解，但可能会因为递归深度过大而导致栈溢出。迭代方法则使用一个显式的栈来保存待访问的节点，这种方法避免了递归可能带来的栈溢出问题，但代码相对复杂一些。

深度优先搜索算法不仅能够帮助我们遍历图中的所有节点，还能用于解决各种实际问题。例如，在解决路径查找问题时，我们可以使用DFS来寻找从起点到终点的所有可能路径。在拓扑排序中，DFS可以用来检测图中是否存在环，以及确定节点的顺序。此外，DFS在解决迷宫问题、拼图游戏以及许多其他需要系统搜索的场合中都发挥着重要作用。

值得注意的是，深度优先搜索在搜索过程中可能会遇到大量的分支，因此在某些情况下，它可能不是最优的选择。特别是在需要找到最短路径或最优解的问题中，广度优先搜索（BFS）或其他更高效的算法可能更为合适。然而，DFS的简洁性和灵活性使其在许多情况下仍然是一个非常有用的工具。

2.2 广度优先搜索

广度优先搜索（Breadth-First Search，简称BFS）是一种广泛应用于图或树结构的遍历算法。它的基本原理是，从一个指定的起始节点开始，首先系统地访问该节点的所有直接相邻的节点，接着再对每一个新访问的节点执行相同的操作，即访问它们的邻近节点。这种搜索方式类似于水面上的波纹逐渐向外扩散，因此得名“广度优先”。

在具体实现上，广度优先搜索通常借助于队列这一数据结构来辅助完成。算法的执行流程如下：首先，将起始节点加入到一个空队列中。随后，进入一个循环，只要队列不为空，就从队列前端取出一个节点进行访问。访问该节点后，将其所有未被访问过的邻近节点依次加入队列的尾部。这个过程不断重复，直到队列为空，此时可以确信所有从起始节点可达的节点都已被访问过。

广度优先搜索的一个显著特点是，它能够在无权图中找到从起始节点到目标节点的最短路径。这是因为算法按照距离起始节点的层数顺序进行访问，确保了最先访问到的路径就是最短的路径。除了用于路径搜索，BFS还被广泛应用于求解最短路径问题、进行拓扑排序，以及解决一些网络流问题。例如，在社交网络分析中，可以使用BFS来找出两个用户之间的关系链，或者在计算机网络中，BFS可以用来检测网络中的环。

此外，BFS算法的另一个优势是它对图的表示没有特别的要求，无论是邻接矩阵还是邻接表，都可以高效地执行搜索。这种灵活性使得BFS成为图论和算法设计中不可或缺的工具之一。通过广度优先搜索，我们能够深入理解图的结构，发现隐藏在复杂网络中的模式和关系，从而在各种实际应用中发挥重要作用。

2.3 A*搜索算法

A*搜索算法，这是一种在计算机科学领域广泛应用的路径查找技术，它巧妙地结合了两种搜索策略：一种是Dijkstra算法的严谨性，另一种是最好优先搜索的直观性。A*算法的核心在于其评估函数f(n)，这个函数是两个关键部分的总和：g(n)和h(n)。其中，g(n)代表了从起始点到当前节点n的实际代价，它确保了算法的准确性；而h(n)则是一个启发式估计，它代表了从当前节点n到目标节点的预期代价，这个估计通常基于特定问题领域的知识或经验。

为了保证A*算法能够找到最优路径，启发式函数h(n)必须满足一定的条件，即它必须是可采纳的，或者说是乐观的。这意味着h(n)给出的估计代价不会超过实际代价，从而保证了算法不会忽略掉最短路径。在实际应用中，h(n)的选取非常关键，它直接影响到算法的效率和效果。一个好的启发式函数可以显著减少搜索空间，提高算法的运行速度。

A*算法之所以受到青睐，是因为它在保证找到最优解的同时，还能够尽可能地减少搜索范围，避免了盲目搜索的低效率。它通过评估函数f(n)来指导搜索方向，优先探索那些看起来更接近目标的路径。这种策略使得A*算法在解决诸如路径规划、游戏AI、机器人导航等需要高效路径查找的问题时，表现得尤为出色。

2.4 Dijkstra算法

Dijkstra算法是一种用于在加权图中找到两个顶点之间最短路径的算法。它由荷兰计算机科学家艾兹赫尔·戴克斯特拉于1956年提出，并于1959年发表。该算法适用于有向图和无向图，且所有边的权重都必须为非负值。

算法的基本原理是贪心策略。它从源点开始，逐步扩展最短路径树，直到包含所有顶点。在每一步中，算法选择当前未处理的顶点中距离源点最近的顶点，并更新其邻接顶点的距离。如果通过当前顶点到达邻接顶点的距离比已知的最短距离更短，则更新该距离。

Dijkstra算法的步骤如下：

1. 将所有顶点分为两个集合：已知最短路径的顶点集合和未知最短路径的顶点集合。初始时，只有源点属于第一个集合，其余所有顶点属于第二个集合。

2. 将源点到自身的距离设为0，到其他所有顶点的距离设为无穷大。

3. 对于当前顶点，检查其所有邻接顶点。对于每一个邻接顶点，如果通过当前顶点到达它的距离比已知的最短距离更短，则更新这个距离。

4. 将当前顶点标记为已处理，并从未处理的顶点集合中选择一个距离源点最近的顶点作为新的当前顶点。

5. 重复步骤3和4，直到所有顶点都被处理。

6. 当算法结束时，所有顶点的最短路径都会被确定。

Dijkstra算法的时间复杂度依赖于所使用的数据结构。如果使用优先队列（如二叉堆），算法的时间复杂度可以降低到O((V+E)logV)，其中V是顶点的数量，E是边的数量。

2.5 Bellman-Ford算法

Bellman-Ford算法是一种用于在带权图中寻找单源最短路径的算法，能够处理包含负权边的图，但不能处理包含负权环的图。其基本原理是通过一系列的松弛操作（relaxation），逐步逼近从源点到所有其他顶点的最短路径。

算法从源点开始，对所有边进行多次遍历。在每次遍历中，算法会检查每条边，并尝试通过这条边来更新到达边的终点的最短路径估计。如果通过这条边到达终点的距离比当前已知的最短路径更短，那么就更新这个最短路径的估计值。

具体步骤如下：

1. 初始化：将源点到自身的距离设为0，源点到其他所有顶点的距离设为无穷大。同时，记录下每条边的权重。

2. 松弛操作：对图中的每条边进行V-1次遍历（V是顶点的数量）。对于每条边(u, v)，如果从源点到顶点u的最短路径加上边(u, v)的权重小于当前顶点v的最短路径估计，则更新顶点v的最短路径估计。

3. 检测负权环：在完成V-1次遍历后，算法再对所有边进行一次遍历。如果在这次遍历中，还能找到通过某条边使得到达终点的距离变得更短，那么说明图中存在负权环。

Bellman-Ford算法的时间复杂度为O(VE)，其中V是顶点数，E是边数。尽管这个算法的时间复杂度较高，但由于其能够处理负权边，因此在某些特定情况下非常有用。

三、图搜索算法实现

3.1 深度优先搜索

#include <stdio.h>
 
// 图的邻接矩阵表示
int graph[6][6] = {
    {0, 1, 0, 0, 0, 0},
    {0, 0, 1, 1, 0, 0},
    {0, 0, 0, 1, 0, 0},
    {0, 0, 0, 1, 1, 0},
    {0, 0, 0, 0, 0, 1},
    {0, 0, 0, 0, 0, 0}
};
 
int n = 6; // 顶点数
int* visited = (int*)malloc(sizeof(int) * n);
 
void DFS(int** graph, int n, int i) {
    visited[i] = 1;
    printf("%d ", i);
    for (int j = 0; j < n; j++) {
        if (graph[i][j] == 1 && !visited[j]) {
            DFS(graph, n, j);
        }
    }
}
 
int main() {
    // 初始化visited数组
    for (int i = 0; i < n; i++) {
        visited[i] = 0;
    }
 
    // 从顶点0开始深度优先搜索
    DFS((int**)graph, n, 0);
 
    return 0;
}

这段代码中，我们使用了一个邻接矩阵来表示图，并定义了一个深度优先搜索函数DFS。在main函数中，我们从顶点0开始进行深度优先搜索，并输出访问的顶点。这个例子展示了DFS算法的基本实现，对于理解DFS算法非常有帮助。

3.2 广度优先搜索

#include <stdio.h>
#include <stdlib.h>
 
#define MAX_VERTICES 10
 
typedef struct Graph {
    int vertexList[MAX_VERTICES];
    int adjMat[MAX_VERTICES][MAX_VERTICES];
    int numVertices;
};
 
void createGraph(struct Graph *graph) {
    // 初始化图
    for (int i = 0; i < MAX_VERTICES; i++) {
        for (int j = 0; j < MAX_VERTICES; j++) {
            graph->adjMat[i][j] = 0;
        }
        graph->vertexList[i] = 0;
    }
    graph->numVertices = 0;
 
    // 添加顶点
    for (int i = 0; i < 5; i++) {
        graph->vertexList[i] = i;
        graph->numVertices++;
    }
 
    // 添加边
    graph->adjMat[0][1] = 1;
    graph->adjMat[0][2] = 1;
    graph->adjMat[1][3] = 1;
    graph->adjMat[1][4] = 1;
    graph->adjMat[3][0] = 1;
    graph->adjMat[4][0] = 1;
}
 
void bfs(struct Graph *graph, int startVertex) {
    int queue[MAX_VERTICES], front = -1, rear = -1;
    int visited[MAX_VERTICES] = {0};
    int v;
 
    // 初始化队列
    for (v = 0; v < graph->numVertices; v++) {
        visited[v] = 0;
    }
 
    // 访问起始顶点并将其放入队列
    printf("%d ", startVertex);
    visited[startVertex] = 1;
    rear++;
    queue[rear] = startVertex;
 
    // 当队列不为空时执行
    while (front != rear) {
        front = (front + 1) % MAX_VERTICES;
        v = queue[front];
 
        // 遍历所有的邻接顶点
        for (int i = 0; i < graph->numVertices; i++) {
            if (graph->adjMat[v][i] == 1 && visited[i] == 0) {
                printf("%d ", i);
                visited[i] = 1;
                rear = (rear + 1) % MAX_VERTICES;
                queue[rear] = i;
            }
        }
    }
}
 
int main() {
    struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph));
    createGraph(graph);
    bfs(graph, 0);
    return 0;
}

这段代码首先定义了一个图结构，然后创建了一个具有5个顶点和几条边的简单图。createGraph函数用于初始化图，并添加顶点和边。bfs函数实现了广度优先搜索算法，它使用一个队列来跟踪访问的顶点，并按照访问的顺序打印它们。

程序的输出将是从顶点0开始的广度优先搜索的顶点访问顺序：0 1 2 3 4。

3.3 A*搜索算法

#include <stdio.h>
#include <stdlib.com>
 
// 定义节点结构体
struct Node {
    int x, y; // 节点坐标
    int g, h, f; // 路径代价、 heuristic 代价和总代价
    struct Node* parent; // 父节点指针
};
 
// 比较函数，用于qsort排序
int compare(const void* a, const void* b) {
    struct Node* node1 = *(struct Node**)a;
    struct Node* node2 = *(struct Node**)b;
    return (node1->f - node2->f);
}
 
// A*搜索算法实现
struct Node* astar_search(int start_x, int start_y, int end_x, int end_y) {
    // 初始化开始节点
    struct Node* start_node = malloc(sizeof(struct Node));
    start_node->x = start_x;
    start_node->y = start_y;
    start_node->g = 0;
    start_node->h = abs(end_x - start_x) + abs(end_y - start_y);
    start_node->f = start_node->g + start_node->h;
    start_node->parent = NULL;
 
    // 模拟节点集合（这里使用链表模拟）
    // ...
 
    // 搜索逻辑
    // ...
 
    // 返回结果
    return NULL; // 假设没有找到路，返回NULL
}
 
int main() {
    // 示例：搜索起点(0, 0)到终点(4, 4)的路径
    struct Node* path = astar_search(0, 0, 4, 4);
    if (path != NULL) {
        printf("Path found!\n");
        // 打印路径
        // ...
    } else {
        printf("No path found!\n");
    }
 
    // 清理资源
    // ...
 
    return 0;
}

这个代码示例提供了A搜索算法的一个简化版本，展示了如何使用C语言定义一个节点结构体，并实现一个简单的A搜索算法。注意，示例中的搜索逻辑和内存管理是不完整的，因为它主要是为了展示A*搜索算法的基本概念。在实际应用中，你需要实现节点的生成、节点集合的管理、边界检查、节点的扩展以及回溯逻辑等。

3.4 Dijkstra算法

#include <stdio.h>
#define INFINITY 65535
#define MAX_VERTICES 10
 
int dist[MAX_VERTICES];
int previous[MAX_VERTICES];
int A[MAX_VERTICES][MAX_VERTICES];
int n, e; // n是顶点数，e是边数
 
void dijkstra(int vertices, int edges, int src) {
    int i, j, min_vertex;
    int src_distance = 0;
 
    // 初始化距离数组和前驱数组
    for (i = 0; i < vertices; i++) {
        dist[i] = A[src][i];
        if (dist[i] == INFINITY)
            previous[i] = -1;
        else
            previous[i] = src;
    }
    dist[src] = src_distance;
 
    // 找出其余顶点之间的最短路径
    for (i = 0; i < vertices - 1; i++) {
        min_vertex = src;
        int min = INFINITY;
        for (j = 0; j < vertices; j++) {
            if (dist[j] < min && dist[j] != INFINITY) {
                min = dist[j];
                min_vertex = j;
            }
        }
        dist[min_vertex] = INFINITY; // 标记已经找到最短路径的顶点
        for (j = 0; j < vertices; j++) {
            if (A[min_vertex][j] < INFINITY && (min + A[min_vertex][j]) < dist[j]) {
                dist[j] = min + A[min_vertex][j];
                previous[j] = min_vertex;
            }
        }
    }
}
 
int main() {
    // 初始化邻接矩阵
    // 假设图是无向图，并且我们使用邻接矩阵来表示
    // 例如：A[i][j] = w 表示顶点i到顶点j的边权重为w
    n = 6; // 顶点数
    e = 8; // 边数
    int weight = 0;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i == j) {
                A[i][j] = 0;
            } else {
                A[i][j] = INFINITY;
            }
        }
    }
    // 根据边数e填充邻接矩阵
    // 例如：0 1 7 5 1 0 2 0 3 0 0 1 6 5 0 0 2 0 0 3 0 0 0 0 0 0 0
    // 表示顶点0到顶点1的权重为7，顶点0到顶点2的权重为5等等
    // 填充代码省略...
 
    // 运行Dijkstra算法，源顶点为0
    dijkstra(n, e, 0);
 
    // 打印最短路径距离和前驱数组
    printf("最短路径距离：\n");
    for (int i = 0; i < n; i++) {
        printf("顶点 %d: %d\n", i, dist[i]);
    }
    printf("前驱数组：\n");
    for (int i = 0; i < n; i++) {
        printf("顶点 %d: %d\n", i, previous[i]);
    }
 
    return 0;
}

以上是使用C语言实现Dijkstra算法的一个简化示例。假设图是以邻接矩阵的形式给出，并且我们假设图不含负权边（如果含有，则算法需要进行相应的修改）。

3.5 Bellman-Ford算法

#include <stdio.h>
#include <stdbool.h>
 
#define MAXV 100         // 最大顶点数
#define INF 100000000    // 用作无穷大的值
 
typedef struct {
    int v[MAXV];         // 顶点表
    int w[MAXV][MAXV];   // 边的权值，假设无向图
    int d[MAXV];         // 保存最短路径的近似值
    int p[MAXV];         // 保存最短路径的前驱
    int n, e;            // 图中的顶点数和边数
} MGraph;
 
// Bellman-Ford算法检测负权回路
bool BellmanFord(MGraph G, int u) {
    int i, j, k;
    bool flag;
 
    for (i = 0; i < G.n; i++) {
        G.d[i] = G.w[u][i];
        if (G.d[i] < INF) G.p[i] = u;
        else G.p[i] = -1;
    }
    G.d[u] = 0;
    G.p[u] = u;
 
    for (k = 1; k < G.n; k++) {
        flag = false;
        for (i = 0; i < G.n; i++) {
            for (j = 0; j < G.n; j++) {
                if (G.d[j] > G.d[i] + G.w[i][j]) {
                    G.d[j] = G.d[i] + G.w[i][j];
                    G.p[j] = i;
                    flag = true;
                }
            }
        }
        if (!flag) break;  // 没有松弛操作，退出循环
    }
 
    for (i = 0; i < G.n; i++) {
        if (G.d[i] > G.d[u] + G.w[u][i]) return true; // 存在负权回路
    }
    return false;
}
 
// 主函数示例
int main() {
    MGraph G;
    // 初始化图G，这里需要根据实际情况填充顶点数、边数和边的权值
    // ...
 
    // 调用BellmanFord算法，检测顶点0是否存在负权回路
    if (BellmanFord(G, 0)) {
        printf("存在负权回路\n");
    } else {
        printf("不存在负权回路\n");
    }
 
    return 0;
}

这个代码实例提供了Bellman-Ford算法的一个简化版本，用于检测图中是否存在负权回路。需要注意的是，这个代码示例没有提供图的具体初始化方式，这部分应该根据实际情况填充图的相关数据。