双向广度优先搜索算法框架

最新推荐文章于 2024-04-12 17:50:45 发布
最新推荐文章于 2024-04-12 17:50:45 发布
阅读量6.7k 收藏 19
点赞数 7
分类专栏： 算法分析 文章标签： 双向广度优先 算法

双向广度优先搜索算法是对广度优先算法的一种扩展。广度优先算法从起始节点以广度优先的顺序不断扩展，直到遇到目的节点；而双向广度优先算法从两个方向以广度优先的顺序同时扩展，一个是从起始节点开始扩展，另一个是从目的节点扩展，直到一个扩展队列中出现另外一个队列中已经扩展的节点，也就相当于两个扩展方向出现了交点，那么可以认为我们找到了一条路径。双向广度优先算法相对于广度优先算法来说，由于采用了从两个跟开始扩展的方式，搜索树的深度得到了明显的减少，所以在算法的时间复杂度和空间复杂度上都有较大的优势！双向广度优先算法特别适合于给出了起始节点和目的节点，要求他们之间的最短路径的问题。另外需要说明的是，广度优先的顺序能够保证找到的路径就是最短路径！

基于以上思想，我们给出双向广度优先算法编程的基本框架如下：

数据结构：

Queue q1, q2; //两个队列分别用于两个方向的扩展（注意在一般的广度优先算法中，只需要一个队列）

int head[2], tail[2]; //两个队列的头指针和尾指针

算法流程:

一、主控函数:

void solve()

{

1. 将起始节点放入队列q1,将目的节点放入队列q2

2. 当 两个队列都未空时，作如下循环

          1) 如果队列q1里的未处理节点比q2中的少（即tail[0]-head[0] < tail[1]-head[1]),则扩展（expand()）队列q1

          2) 否则扩展（expand()）队列q2 (即tail[0]-head[0] >= tail[1]-head[1]时)

3. 如果队列q1未空，循环扩展（expand()）q1直到为空

4. 如果队列q2未空，循环扩展（expand()）q2知道为空

}

二、扩展函数:

int expand(i) //其中i为队列的编号(表示q0或者q1)

{

          取队列qi的头结点H

          对头节点H的每一个相邻节点adj，作如下循环

                1 如果adj已经在队列qi之前的某个位置出现，则抛弃节点adj

                2 如果adj在队列qi中不存在[函数 isduplicate(i)]

                      1） 将adj放入队列qi

                      2)    如果adj 在队列(q(1-i))，也就是另外一个队列中出现[函数 isintersect()]

                                      输出 找到路径 

}

三、判断新节点是否在同一个队列中重复的函数

int isduplicate(i, j) //i为队列编号，j为当前节点在队列中的指针

{

            遍历队列,判断是否存在【线性遍历的时间复杂度为O（N)，如果用HashTable优化，时间复杂度可以降到O(1)]

}

四、判断当前扩展出的节点是否在另外一个队列出现，也就是判断相交的函数：

int isintersect(i,j) //i为队列编号，j为当前节点在队列中的指针

{

          遍历队列,判断是否存在【线性遍历的时间复杂度为O（N)，如果用HashTable优化，时间复杂度可以降到O(1)]

}

 

      以上为双向广度优先搜索算法的基本思路，下面给出使用上面的算法框架编写的八数码问题的代码：

问题描述:

给定 3 X 3 的矩阵如下:
2     3     4

1     5      x

7     6     8

程序每次可以交换"x"和它上下左右的数字，

经过多次移动后得到如下状态:

1      2     3

4      5     6

7      8      x

输出在最少移动步数的情况下的移动路径[每次移动的方向上下左右依次表示为'u', 'd', 'l', 'r']

 

例如：

如果过输入:【将矩阵放到一行输出】

 2  3  4 1  5  x  7  6  8

则输出:

ullddrurdllurdruldr

原题见ACM PKU 1077

‍C++代码如下：【注意，这是没有使用HASH优化的版本，压线通过了ACM PKU在线测试的内存和时间要求】

 

/*
 * Author: puresky
 * Date: 2010.01.12
 * Purpose: solve EIGTH NUMBER problem!
 */

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

#define MAXN 1000000

#define SWAP(a, b) {char t = a; a = b; b = t;}

typedef struct _Node Node;

struct _Node
{
        char tile[10]; // represent the tile as a string ending with '\0'
        char pos;   // the position of 'x'
        char dir;  //the moving direction of 'x'
        int parent; //index of parent node
};

int head[2], tail[2];
Node queue[2][MAXN];// two queues for double directoin BFS

//shift of moving up, down, left ,right
int shift[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

//for output direction!
char dir[4][2] = {{'u', 'd'}, {'d', 'u'}, {'l', 'r'}, {'r', 'l'}};

//test case
char start[10] = "23415x768";
char end[10] = "12345678x";

//read a tile 3 by 3
void readtile()
{
        int i;
        char temp[10];
        for(i = 0; i < 9; ++i)
        {
                scanf("%s", temp);
                start[i] = temp[0];
        }
        start[9] = '\0';
}

//print result
void print_backward(int i)
{
        if(queue[0][i].parent != -1)
        {
                print_backward(queue[0][i].parent);
                printf("%c", queue[0][i].dir);
        }
}
void print_forward(int j)
{
        if(queue[1][j].parent != -1)
        {
                printf("%c", queue[1][j].dir);
                print_forward(queue[1][j].parent);
        }
}
void print_result(int i, int j)
{
        //printf("%d,%d\n", i, j);
        print_backward(i);
        print_forward(j);
        printf("\n");
}

//init the queue
void init(int qi, const char* state)
{
        strcpy(queue[qi][0].tile, state);
        queue[qi][0].pos = strchr(state, 'x') - state;
        queue[qi][0].parent = -1;

        head[qi] = tail[qi]  = 0;
}

//check if there are duplicates in the queue
//time comlexity:O(n)
//We can optimise this function using HashTable
int isduplicate(int qi)
{
        int i;
        for(i = 0; i < tail[qi]; ++i)
        {
                if(strcmp(queue[qi][tail[qi]].tile, queue[qi][i].tile) == 0)
                {
                        return 1;
                }
        }
        return 0;
}

//check if the current node is in another queue!
//time comlexity:O(n)
//We can optimise this function using HashTable
int isintersect(int qi)
{
        int i;
        for(i = 0 ; i < tail[1 - qi]; ++i)
        {
                if(strcmp(queue[qi][tail[qi]].tile, queue[1 - qi][i].tile) == 0)
                {
                        return i;
                }
        }

        return -1;
}

//expand nodes
int expand(int qi)
{
        int i, x, y, r;

        Node* p = &(queue[qi][head[qi]]);
        head[qi]++;

        for(i = 0; i < 4; ++i)
        {
                x = p->pos / 3 + shift[i][0];
                y = p->pos % 3 + shift[i][1];
                if(x >= 0 && x <= 2 && y >= 0 && y <= 2)
                {
                        tail[qi]++;
                        Node* pNew = &(queue[qi][tail[qi]]);
                        strcpy(pNew->tile, p->tile);
                        SWAP(pNew->tile[ 3 * x + y], pNew->tile[p->pos]);
                        pNew->pos = 3 * x + y;
                        pNew->parent = head[qi] - 1;
                        pNew->dir = dir[i][qi];
                        if(isduplicate(qi))
                        {
                                tail[qi]--;
                        }
                        else
                        {
                                if((r = isintersect(qi)) != -1)
                                {
                                        if(qi == 1)
                                        {
                                                print_result(r, tail[qi]);
                                        }
                                        else
                                        {
                                                print_result(tail[qi], r);
                                        }
                                        return 1;
                                }
                        }
                }
        }
        return 0;
}

//call expand to generate queues
int solve()
{
        init(0, start);
        init(1, end);
       
        while(head[0] <= tail[0] && head[1] <= tail[1])
        {
                //expand the shorter queue firstly
                if(tail[0] - head[0] >= tail[1] - head[1])
                {
                        if(expand(1)) return 1;
                }
                else
                {
                        if(expand(0)) return 1;
                }
        }
       
        while(head[0] <= tail[0]) if(expand(0)) return 1;
        while(head[1] <= tail[1]) if(expand(1)) return 1;
        return 0;
}

int main(int argc, char** argv)
{
        readtile();
        if(!solve())
        {
                printf("unsolvable\n");
        }
        //system("pause"); //pause
        return 0;
}

ACM Judge Online: 372K 内存， 938MS 时间


以上内容为转载。接下来附上我参考该转载文章写的POJ1077双向广搜代码：

<span style="color:#ff0000;">Source Code

Problem: 1077		User: liangrx06
Memory: 15316K		Time: 141MS
Language: C++		Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;

typedef int State[9];
const int M = 1000000;
State st[M], goal;
//int dist[M];
int pre[M];
char move[M];

const int HASH_SIZE = M+3;
int head[HASH_SIZE], next[HASH_SIZE];

void init_lookup_table()
{
    memset(head, 0, sizeof(head));
    memset(next, 0, sizeof(next));
}

bool legal(int x, int y)
{
    return 0 <= x && x < 3 && 0 <= y && y < 3;
}

int hash(State& s)
{
    int t = 0;
    for (int i = 0; i < 9; i++) t = t * 10 + s[i];
    return t % HASH_SIZE;
}

bool try_to_insert(int k)
{
    int h = hash(st[k]);
    int u = head[h];
    while (u) {
        if (memcmp(st[u], st[k], sizeof(st[k])) == 0) return false;
        u = next[u];
    }
    next[k] = head[h];
    head[h] = k;
    return true;
}

const int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const char move_type[] = "drul";
int BFS()
{
    init_lookup_table();

    int front = 1, rear = 2;
    while (front < rear) {
        State& s = st[front];
        if (memcmp(goal, s, sizeof(s)) == 0)
            return front;
        int z;
        for (z = 0; z < 9; z++) if (!s[z]) break;
        int x = z/3, y = z%3;
        for (int i = 0; i < 4; i++) {
            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            if (legal(nx, ny)) {
                int nz = nx*3 + ny;
                State& t = st[rear];
                memcpy(t, s, sizeof(s));
                swap(t[z], t[nz]);
                if (try_to_insert(rear)) {
                    //dist[rear] = dist[front] + 1;
                    pre[rear] = front;
                    move[rear] = move_type[i];
                    rear++;
                }
            }
        }
        front ++;
    }
    return 0;
}
        
int main(void)
{   
    char str[2];
    for (int i = 0; i < 9; i++) {
        scanf("%s", str);
        st[1][i] = (str[0] == 'x') ? 0 : str[0]-'0';
        goal[i] = (i+1)%9; 
    } 
    //dist[1] = 0;

    int step = BFS();
    vector<char> res;
    while (step != 1) { 
        res.push_back(move[step]);
        step = pre[step];
    }   
    for (int i = res.size()-1; i >= 0; i--)
        printf("%c", res[i]);
    printf("\n");
        
    return 0;
}</span>

梁山伯liangrx06
关注
  • 7
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
算法第十三期——BFS-双向广搜
荷叶田田的博客
01-16 947
BFS优化---双向广搜
双向广度优先搜索
majcos的专栏
05-23 3605
 双向广度优先搜索　　广度优先搜索遵循从初始结点开始一层层扩展直到找到目标结点的搜索规则，它只能较好地解决状态不是太多的情况，承受力很有限。如果扩展结点较多，而目标结点又处在较深层，采用前文叙述的广度搜索解题，搜索量巨大是可想而知的，往往就会出现内存空间不够用的情况。双向搜索和A算法对广度优先的搜索方式进行了改良或改造，加入了一定的“智能因素”，使搜索能尽快接近目标结点，减少了在空间和时间
双向广度优先搜索算法
weixin_38187159的博客
10-02 1670
转自http://www.cppblog.com/tortoisewu/archive/2009/05/29/86123.aspx 首先是广度优先搜索算法 初始化visited数组，将所有点的值设为false；//visited数组用来保存所有点的访问情况 visited[start]=true;//start为起始点 queue&lt;type&gt; search;//用来保存待搜索点的...
17 | 时间和空间复杂度（下）：如何使用六个法则进行复杂度分析？
最新发布
qq_37756660的博客
04-12 836
今天我们接着聊复杂度分析的实战。上一讲，从数学的角度出发，结合自身经验给你总结了几个分析复杂度的法则。但是在实际工作中我们会碰到很多复杂的问题，这个时候，正确地运用这些法则并不是件容易的事。今天，就结合几个案例，教你一步步使用这几个法则。
双向搜索算法（基于深度优先搜索算法的优化）
lslskkkyy的博客
04-26 1061
这种算法通常用于搜索问题，其中起点和终点之间的距离较远，而搜索空间较大，例如在图形搜索、字符串匹配和游戏搜索中。双向搜索算法的应用非常广泛，例如在图形搜索中，可以从起点和终点同时开始搜索，以找到最短路径。4. 可能会忽略一些解：深度优先算法只会搜索一条路径，如果存在多个解决方案，但是它们不在同一条路径上，那么深度优先算法可能会忽略其中一些解决方案。3. 空间复杂度高：深度优先算法需要使用递归或者栈来保存搜索过程中的状态，因此在搜索深度较大的情况下，空间复杂度会很高，可能会导致内存溢出。
双向搜索的理解和板子
louisdlee的博客
01-18 1198
/开一个二维map，m[i][string]= step;无论0在哪个位置，它都可以往四个方向交换，当然，这里面有很多无效的操作，所以我们考虑剪枝，如果它交换后的坐标，是合法坐标，那么我们认为这次交换时有效的。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
2.4.4 用N-S 流程图表示算法 29 2.4.5 用伪代码表示算法 30 2.4.6 用计算机语言表示算法 31 2.5 结构化程序设计方法 31 3 数据类型、运算符与表达式 3.1 Ｃ语言的数据类型 32 3.2 常量与变量 33 23.2.1 常量和符号...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
2.4.4 用N-S 流程图表示算法 29 2.4.5 用伪代码表示算法 30 2.4.6 用计算机语言表示算法 31 2.5 结构化程序设计方法 31 3 数据类型、运算符与表达式 3.1 Ｃ语言的数据类型 32 3.2 常量与变量 33 23.2.1 常量和符号...
人工智能导论课件：课程总结.ppt
06-18
常见的图搜索算法有深度优先搜索、宽度优先搜索和启发式图搜索等。 深度优先搜索是指从初始状态开始，逐步深入搜索，以找到问题的解。深度优先搜索可以解决问题的搜索空间，但是存在死循环问题。 宽度优先搜索是指...
大学人工智能期末考试题库.doc
09-24
盲目搜索主要有宽度优先搜索、深度优先搜索、有界深度优先搜索、代价树的宽度优先搜索和代价树的深度优先搜索等策略。 六、不确定性 证据传递的不确定性是指在推理过程中，不确定的初始证据会沿着推理链向下传递，...
试给出有向图中所有简单回路的算法_从入门角度深入理解——有关最短路的常见算法#1 最短路问题介绍...
weixin_39933508的博客
12-17 1648
最短路问题介绍这里的最短路问题，指的是单源最短路。单源最短路，意如其名，只有一个原点，走到其他点的最短路径。即求一个点到其余点的最短路径。图的简单概述：要了解最短路，首先要简单理解一下什么是图。书上概述如下(可以跳过不读)：图G=(V,E)是一个二元组(V,E)使得E⊆[V]的平方，所以E的元素是V的2-元子集。为了避免符号上的混淆，我们总是默认V∩B=Ø。集合V中的元素称为图G的顶点(或节点、点...
八数码问题—双向广度优先搜索（C++实现）
05-01
八数码问题，广度优先搜索，用C++实现。 八数码问题即： 一个3*3的格子，其中8个小方格里各有个数字， 另外一个格子是空的，它临近的数字可以移动到这个空格子里。 给定一个八数码的起始状态，和一个终止状态，通过哪些步骤能够实现这种转换。
最短哈密顿回路算法C语言实现
10-09
最短哈密顿回路，在无向图中由一个顶点出发，不重复的遍历所有顶点，最后回到出发点，找到最短的回路，用C语言实现，
双向广度优先搜索法。
老侃研究院CSDN分院
01-19 2969
上一篇文章里讲到了广度优先搜索法，并以8数码问题为例。8数码问题比较简单，一般不超过30步即可求解。搜索的节点也不会超过1000000。而如下这个问题的步数是56，如果直接用广度优先搜索，节点数量会多的难以想象。########BLACK### # ##     #是墙#WHITE########    |  ########WHITE### # ###BLACK########问题就是将
广度优先搜索（BFS）
JOSEPHCAMPBELL的博客
10-04 314
BFS（1）
广度优先搜索双队列通用编程模板
Talk is cheap,show me your code
08-11 607
给出广度优先搜索的总结和具体实现
搜索技术【广度优先搜索】 - 简介 & 分支限界法
谢谢你们的关注
11-10 648
搜索技术【广度优先搜索】 - 简介 & 分支限界法
数据结构与算法(四) 广度优先搜索
半虹小站
11-15 2916
本篇文章继续来学习广度优先搜索算法（Broad-First-Search，BFS）
C++ 双向广度搜索，嚯嚯！不就是双指针理念吗
y6123236的专栏
02-16 1141
在线性数据结构中搜索时，常使用线性搜索算法，但其性能偏低下，其性能改善方案常有二分搜索和双指针或多指针搜索算法。在复杂的数据结构如树和图中，常规搜索算法是深度和广度搜索。在深度搜索算法过程中常借助剪枝或记忆化方案提升搜索性能。广度搜索算法过程中常见的性能优化方案为双向广度搜索和启发式搜索。双向广度搜索可以认为是图论中的双指针搜索方案，本文将和大家深入探讨其算法细节。图中常见的操作为最短路径查找。如在下面的无向无权重图中查找节点1到节点6之间的最短路径，可以直接使用广度搜索算法找到。//邻接矩阵。
广度优先搜索算法结合弗洛伊德算法
09-17
广度优先搜索算法（BFS）和弗洛伊德算法是两种不同的算法，分别用于解决不同的问题。 广度优先搜索算法是一种图遍历算法，用于在无权图或者权重相等的图中找到从起始节点到目标节点的最短路径。它通过逐层扩展搜索...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值