BFS 最短路径证明及实现

最新推荐文章于 2024-09-28 22:54:33 发布
最新推荐文章于 2024-09-28 22:54:33 发布
阅读量7.2k 收藏 11
点赞数 4
分类专栏： 算法导论相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdq347/article/details/9526833
版权

BFS最短路径感觉是显而易见的，但证明却颇费工夫，以下证明大部分摘自CLRS，使用倒序形式进行证明比较好理解。首先需要证明一条引理，即BFS中所有点的d值按照入队列成升序排列，即d(s) <= d(v1) <= ... <=d(vr)。

 

1. BFS得到的是一条路径，即从起始点s到任意一点v的路径d(v)，因此它必定大于等于最短路径δ(s,v)，即有d(v) >=δ(s,v)

 

2. 以下只需要证明d(v)>δ(s,v)情况不存在即可，故假设d(v) >δ(s,v)再得到矛盾。

 

使用数学归纳法进行证明d(v) =δ(s,v)，对δ(s,v)的长度进行归纳证明，当δ(s,v)＝0时显然成立，当且仅当s=v；当δ(s,v)＝1时也成立，这些v必定和s直接相连，故由DFS的过程可知，这些d(v)均等于1，故也成立；以下假设对长度为δ(s,v)<=n时均成立。

当δ(s,v)=n+1时，即s到v的最短路径长度为n+1，假设经过BFS得到d(v) >δ(s,v)，设s到v的最短路径中u为v的上一个结点，由最短路径的定义可知δ(s,u) =δ(s,v) – 1 = n，由以上的归纳假设可知δ(s,u)=d(u)，即有如下不等式：

d(v) >δ(s,v) = d(u)+ 1

 

当点v出队列时，点u只有三种情况，白色、灰色、黑色，以下证明这三种情况均会导致矛盾。

(1) 点u白色，由于点u、v相邻，根据BFS过程，d(u) =d(v) + 1，于d(v) > d(u) + 1矛盾；

(2) 点u灰色，则表明在处理某个点w时将u置为灰色，由于w已经出队列，根据引理有d(w)<=d(u)，而d(v) = d(w)+1，则有d(v) <= d(u) + 1，矛盾；

(3) 点u黑色，则表明点u在v之前出队列，故d(u)<=d(v)，也有矛盾。

由此可知BFS 确实是最短路径。

 

引理：BFS处理过程中，假设队列Q中的点为 v1, v2, ..., vr，其中v1是队列头，升序排列，即d (v1)<=d(v2)<= ...<=d(vr)，而且d (v1) +1 >= d(vr)，即最多只有两个d值

 

使用数学归纳法进行证明，当刚开始只有点s时，命题显然。然后证明当某个点出队列、入队列这两个过程均不会改变这两种属性即可。

1. 出队列过程，由于归纳假设d(v1)+ 1>=d(vr)，且为升序，点v1出队列，v2成为队列头，升序这个属性不会改变，而且d(v2) + 1>=d(v1) + 1>=d(vr)，故命题依然成立；

2. 入队列过程，假设新入队列的点为vr+1，则vr+1必定由v1之前的点u加入，即d(v1) >＝d(u)，d(vr+1) = d(u) + 1，当点u出队列以前，Q队列中有r+1个点，u,v1,v2, ..., vr，根据归纳假设，d(u) + 1>=d(vr)，于是有d(vr+1)>= d(vr)，即队列的单调升序属性依然存在。d(v1) + 1>=d(u)+1= d(vr+1)，故引理得证。


树结构使用邻接表进行存储，使用linux_kernel 中的链表操作，如下：

#include "list.h"               /* list from Linux_kernel */

struct link_vertex {            /* vertex type */
    int vindex;
    struct list_head head;      /* linked to all edges */
    struct list_head qnode;     /* used for Queue when BFS */
};

struct link_edge {              /* edge type */
    struct list_head node;
    int vindex;
    int weight;
};

struct link_graph {
    int vcount;
    int ecount;
    struct link_vertex *v;
};

BFS过程相当明显，和CLRS中的伪码极其相似 

void print_path(struct link_graph *G, int s, int v, struct link_vertex **pi)
{
    if (v == s)
        printf("%d ", v);
    else {
        if (pi[v] == NULL)
            printf("no path from %d to %d exists\n", s, v);
        else {
            print_path(G, s, pi[v]->vindex, pi);
            printf("%d ", v);
        }
    }
}


int BFS(struct link_graph *G, int vindex)
{
    int *color, *d, i = 0;
    struct link_vertex **pi;
    struct list_head queue;
    struct link_vertex *v = NULL;

#define COLOR_WHITE 0
#define COLOR_GRAY  1
#define COLOR_BLACK 2
    
    if (vindex >= G->vcount)
        return -1;
    color = malloc(sizeof(int) * G->vcount);
    d = malloc(sizeof(int) * G->vcount);
    pi = malloc(sizeof(struct link_vertex *) * G->vcount);

    for (i = 0;i < G->vcount;i++) {
        v = G->v + i;
        color[i] = COLOR_WHITE;
        d[i] = -1;
        pi[i] = NULL;
    }

    color[vindex] = COLOR_GRAY;
    d[vindex] = 0;
    pi[vindex] = NULL;
    INIT_LIST_HEAD(&queue);

    v = G->v + vindex;
    list_add_tail(&v->qnode, &queue);

    while (!list_empty(&queue)) {
        struct link_edge *lv = NULL;
        
        v = list_entry(queue.next, struct link_vertex, qnode);
        list_del(&v->qnode);
        
        list_for_each_entry(lv, &v->head, node) {
            if (color[lv->vindex] == COLOR_WHITE) {
                color[lv->vindex] = COLOR_GRAY;
                pi[lv->vindex] = v;
                d[lv->vindex] = d[v->vindex] + 1;
                list_add_tail(&(G->v + lv->vindex)->qnode, &queue);
            }
        }
        color[v->vindex] = COLOR_BLACK;
    }

    printf("\nThe path from %d to %d\n", vindex, vindex + 1);
    print_path(G, vindex, (vindex + 1) % G->vcount, pi);
    printf("\n");

    free(pi);
    free(d);
    free(color);

    return 0;
}

随机生成一个邻接矩阵形式的图，然后再将这个邻接矩阵转化为邻接表存储，以下代码可以直接复制测试(要注意必须将linux_kernel 的链表操作list.h 包含进来) 

static int link_edge_init(struct link_graph *G, struct link_vertex *v, int vcount, int *weight)
{
    int i = 0;
    struct link_edge *lv = NULL;

    for (i = 0;i < vcount;i++) {
        if (v->vindex == i || weight[i] == 0)
            continue;
        lv = malloc(sizeof(struct link_edge));
        if (lv == NULL)
            return -1;

        lv->vindex = i;
        lv->weight = weight[i];
        list_add(&lv->node, &v->head);
        G->ecount++;
    }

    return 0;
}


int link_graph_init(struct link_graph *G, int vcount, int *weight)
{
    int i = 0;
    struct link_vertex *v = NULL;

    G->ecount = 0;
    G->vcount = vcount;
    G->v = malloc(sizeof(struct link_vertex) * vcount);
    if (G->v == NULL) {
        printf("OOM for G->v\n");
        return -1;
    }

    for (i = 0;i < vcount;i++) {
        v = G->v + i;
        v->vindex = i;
        INIT_LIST_HEAD(&v->head);
        link_edge_init(G, v, vcount, weight + i * vcount);
    }

    return 0;
}


void link_graph_exit(struct link_graph *G)
{
    int i = 0;
    struct link_vertex *v = NULL;
    struct link_edge *lv = NULL, *tmp = NULL;
    
    for (i = 0;i < G->vcount;i++) {
        v = G->v + i;
        list_for_each_entry_safe(lv, tmp, &v->head, node) {
            free(lv);
        }
    }

    free(G->v);
}


void link_graph_print(struct link_graph *G)
{
    int i = 0;
    struct link_vertex *v = NULL;
    struct link_edge *lv = NULL;

    printf("G has %d vertexes and %d edges\n", G->vcount, G->ecount);
    for (i = 0;i < G->vcount;i++) {
        v = G->v + i;        
        printf("vindex, %4d\n", v->vindex);
        list_for_each_entry(lv, &v->head, node) {
            printf("[%4d,%4d], ", lv->vindex, lv->weight);
        }
        printf("\n");
    }
}


int main(int argc, char **argv)
{
    int i, j;
    int n = 10, r = 0;
    int **matrix = NULL, *p = NULL;
    struct link_graph G;

    if (argc >= 2) {
        n = strtoul(argv[1], 0, 0);
    }

    p = malloc(n * n * sizeof(int));
    memset(p, 0, n * n * sizeof(int));
    matrix = malloc(n * sizeof(int *));
    for (i = 0;i < n;i++) {
        matrix[i] = p + i * n;
    }

#if 1
    srand(time(0));
    for (i = 0;i < n;i++) {
        for (j = 0;j < n;j++) {
            r = rand();
            if ((r & 0xf) == 0)
                matrix[i][j] = 1;
        }
    }
#else
(void)r;
    matrix[0][0] = matrix[0][1] = matrix[0][2] = matrix[0][3] = 1;
    matrix[1][2] = matrix[1][3] = 1;
    matrix[2][0] = matrix[2][1] = 1;
    matrix[3][0] = 1;
#endif

    for (i = 0;i < n;i++) {
        for (j = 0;j < n;j++) {
            printf("%4d ", matrix[i][j]);
        }
        printf("\n");
    }

    link_graph_init(&G, n, p);
    link_graph_print(&G);

    BFS(&G, 0);

    link_graph_exit(&G);
    free(matrix);
    free(p);

    return 0;
}


wdq347
关注
专栏目录
【数据结构】-图-BFS求解单源最短路径
vector的博客
06-26 4908
该算法以BFS为基础，bfs实现见笔者的另一篇文章 void BFS_Min_Distance(ALGraph G, int u) { queue < int> q; vector<int> dis(G.vecnum, 999); dis[u] = 0;//自己到自己的距离是0 q.push(u); visited[u] = true; while (!q.empty()) { u = q.front(); q.pop(); for (ArcNode.
详解图的最短路径算法（BFS、Dijkstra、Floyd）（附上图解步骤）
叶小树咯
03-23 6911
详解图的最短路算法、针对BFS、Dijkstra、Floyd算法写出详细的图解、解题步骤
算法设计与实验报告—bfs-based 最短路径
12-27
这是a BFS-based shortest path program。其中包含算法和程序源代码，完整的实验报告模板。
迷宫问题(bfs)
qq_43738331的博客
11-05 1156
给定一个 n×nn×n 的二维数组，如下所示： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 数据保证至少存在一条从左上角走到右下角的路径。 输入格式 第一行包含整数 n。 接下来 nn 行，每行包含 nn 个整数 0 或 1，表示迷宫
【图计算算法‌】广度优先搜索（BFS）算法
最新发布
大雨淅淅的博客
09-28 2051
广度优先搜索（BFS）算法是一种在图或树数据结构中广泛应用的遍历算法。它按照从起始节点开始，逐层向外扩展的顺序访问节点，直到找到目标节点或遍历完所有可达的节点
BFS计算最短路径（python)
cindera的刷题记录
03-06 3852
我们这里所说的最短路径是从根节点到某一指定叶子节点的最短路径。 如上图，我们把E,当成根节点，我们到B的最短路径就是ECB。 我们用代码来实现。我们用到的思路就是使用一个字典来存放节点的父节点，仔细看parent和ver 的关系，ver是取到的队头元素，我们用for循环在grep[ver]中找到子元素，所以我们可以反过来用parent[i] = ver 来存放子对父的key_value。 grap = { "A": ["B", "C"], "B": ["A", "C", "D".
bfs的证明
Stephen_Zhao0的博客
06-25 583
①两段性： 队列中最多存在两段：前面是x、x、x，后面是x+1、x+1…后面这段可能不存在 ②单调性：（数学归纳法） Ⅰ初始时：只有一个点显然满足单调性 Ⅱ：假设当前满足条件，x、x、x、x+1、x+1.此时取出队头，找出能够扩展到的点，如果已经被遍历过则忽略，那么因为边长都是1，所以扩展到的点的距离都是x+1，将这些点放到队尾，此时队列仍然具有单调性和两段性。 ...
【基础算法总结】BFS 解决最短路径问题
fight_p的博客
08-12 1895
【基础算法总结】BFS 解决最短路径问题
无人驾驶汽车系统入门——最短路径搜索之A*算法
01-27
可以证明，只要从起点开始的扩散过程能够遍历到终点，那么起点和终点之间一定是连通的，因此他们之间至少存在一条路径，而由于BFS从中心开始呈放射状扩散的特点，它所找到的这一条路径就是最短路径，下图演示了BFS的...
BFS+优先队列——迷宫最短路径——两种最优方法比较及详细图解
qq_36523667的博客
11-30 7839
http://blog.csdn.net/qq_36523667/article/details/78638354 这个链接里是一道迷宫题。用到了BFS+优先队列。 我一直百思不得其解优先队列到底优先在哪了？我感觉和直接bfs没啥区别？后来证明做法不一样，思路也不一样。 所以这里引出另一种最优的做法。 正常的bfs 黑色是当前的点，黄色是即将探索的点，把黄色的依次
bfs求最短路径
xiaoxiao66668的博客
03-01 456
好久没写搜索，到忘了，找了半个小时错误。一开始又把题看错了，真服自己了。（认真审题）这题可以用excel写。but作为一个程序园，那就要使用灵魂操作。核心算法：bfs层次遍历 1 #include <bits/stdc++.h> 2 using namespace std; 3 4 string s[35]; 5 int vist[35][55];//标记...
BFS找最短路径
lyhizjj的博客
03-10 412
if (maze[nxt.x][nxt.y] == '.') {//不是墙壁，修改迷宫标记为走过的总长度。通过队列进行实现，起点入队，搜索四周，可行路径全部入队，起点出队，依次递归，即可实现搜索。每组数据第一行包含两个数n=100，m
BFS 最短路径
weixin_51671868的博客
04-17 130
文章目录 #include <bits/stdc++.h>//最短路径 using namespace std; int a[100][100], v[100][100] = {0}; struct point{ int x; int y; int step; }; queue<point> r; int dx[4] = {0, 1, 0, -1}; int dy[4] = {1, 0, -1, 0}; int main(){ int h, w, startx, star
Python|利用BFS求表格中的最短路径
算法与编程之美
01-21 1384
欢迎点击「算法与编程之美」↑关注我们！本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。问题描述如何用BFS算法解决力扣平台上一道困难题目。给你...
数据结构寻找最短路径BFS（邻接矩阵，邻接表），dijkstra，floyd
wang1chen2的博客
03-12 577
BFS，最短路径，邻接表，邻接矩阵，dijkstra
BFS最短路径（求x到y的最少计算次数）
qq_35747066的博客
08-12 984
链接：https://www.nowcoder.com/questionTerminal/45d04d4d047c48768543eeec95798ed6?f=discussion 来源：牛客网 给定两个-100到100的整数x和y,对x只能进行加1，减1，乘2操作，问最少对x进行几次操作能得到y？ 例如： a=3,b=11: 可以通过3*2*2-1，3次操作得到11； a=5,b=8：可...
BFS(最短路径问题）
qq_52531977的博客
05-09 346
简单最短路径问题 Theme #include<iostream> #include<cstdio> #include<cstdlib> #include<algorithm> #include<queue> #include<cmath> #include<vector> //#include<pair> using namespace std; const int N=333; int dis[N][N],
最短路径问题--BFS算法
清影的博客
06-24 437
最短路径问题--BFS算法
图的理论与应用：从定义到最短路径
"该资源是一份关于图的课件，主要涵盖了图的定义、存储结构、遍历方法、连通性问题、有向无环图（DAG）及其应用以及最短路径等内容。课件中还包含了一些示例图形来帮助理解各种图的概念。" 在计算机科学中，图是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值