POJ 1915_双向BFS

原创 2018年04月15日 12:25:34

前提

使用双向BFS前提是:我们要知道起点和终点的位置,并且这个题要使用BFS求解

我们分别从起点和终点开始进行BFS,以起点开始的BFS的将标记数组记为1,以终点开始的BFA标记数组为2,那么当起点的BFS遇到标记为2的点时或者终点为起点的BFS遇到标记为1的点时我们就找到了答案,答案就是两边步数的相加......

双向BFS的基本思路是这样的.....下面试程序的实现:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <vector>
#include <algorithm>

using namespace std;
const int M = 310;
int vis[M][M],step[M][M],len;
const int dx[8] = {-1,-2,-2,-1,1,2,2,1};
const int dy[8] = {-2,-1,1,2,2,1,-1,-2};
struct node{
    int x,y;
    node(){}
    node(int x,int y):x(x),y(y){}
}st,en;

int limit(node a){
    return (a.x >= 0 && a.x < len && a.y >= 0 && a.y < len);
}

int BFS()
{
    if(st.x == en.x && st.y == en.y)return 0;
    queue<node> que[2];
    que[0].push(st);que[1].push(en);
    vis[st.x][st.y] = 1;vis[en.x][en.y] = 2;
    while(!que[0].empty() && !que[1].empty())
    {
        if(!que[0].empty())
        {
            node q = que[0].front();que[0].pop();
            for(int i =0 ;i < 8;i ++)
                if(limit(node(q.x + dx[i],q.y + dy[i])))
                {
                    node now = node(q.x + dx[i],q.y+dy[i]);
                    if(vis[now.x][now.y] == 2)
                        return step[q.x][q.y] + step[now.x][now.y]+1;
                    else if(!vis[now.x][now.y])
                    {
                        vis[now.x][now.y] = 1;
                        step[now.x][now.y] = step[q.x][q.y] +1;
                        que[0].push(now);
                    }
                }
        }
        if(!que[1].empty())
        {
            node q = que[1].front();que[1].empty();
            for(int i = 0;i < 8;i ++)
                if(limit(node(q.x + dx[i],q.y+dy[i])))
                {
                    node now = node(q.x + dx[i],q.y + dy[i]);
                    if(vis[now.x][now.y] == 1)
                        return step[q.x][q.y] + step[now.x][now.y] +1;
                    else if(!vis[now.x][now.y])
                    {
                        vis[now.x][now.y] = 2;
                        step[now.x][now.y] = step[q.x][q.y] +1;
                        que[1].push(now);
                    }
                }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&len);
        scanf("%d%d%d%d",&st.x,&st.y,&en.x,&en.y);
        memset(vis,0,sizeof(vis));
        memset(step,0,sizeof(step));
        printf("%d\n",BFS());
    }
    return 0;
}

POJ 1915-Knight Moves (单向BFS && 双向BFS 比较)

双向BFS && 普通BFS
  • u013497151
  • u013497151
  • 2014-06-26 17:10:56
  • 1184

POJ - 1077 Eight : 八数码 -- 哈唏 康托展开 双向bfs A* IDA*

前言 做完这道题,感觉整个人都完整了。 这道题所能涉及到的知识点特别多,列举如下: STL判重 Hash判重 康托展开 双向bfs A* IDA* 每一...
  • a27038
  • a27038
  • 2017-07-21 16:48:15
  • 421

poj 2243 双向bfs和A*

题目大意:就是给你一个起点和一个终点,按骑士的走法,从起点到终点的最少移动多少次 解题思路:水题~~~直接bfs就可以了,没写过双向bfs,这次训练一下,双向bfs就是用两个队列,一个队列保存从起点...
  • xiaoxiaoluo
  • xiaoxiaoluo
  • 2012-05-16 01:57:39
  • 1752

POJ2243 A*算法BFS

A*算法是一种有预判优化的搜索根据两个参数g和h和优先队列,选择比较好的下一步。 #include #include #include #include #include #include...
  • cugb1004101218
  • cugb1004101218
  • 2013-04-07 19:01:57
  • 583

uva 1601 poj 3523 Morning after holloween 万圣节后的早晨 (经典搜索,双向bfs+预处理优化+状态压缩位运算)

直接上代码,注释在代码里,注意巧妙地数据规模256 #include #include #include #include #include using namespace std; const i...
  • jc514984625
  • jc514984625
  • 2016-06-25 22:26:26
  • 405

所谓的 双向BFS

双向BFS,既然是双向的,那么就得知道起点和终点,这样,我们就可以进行双向搜索了。 但是,双向BFS是否真的可以提高效率呢?如果能,那么又能提高多少呢? 看到过一个图,说双BFS可以在BFS的基础上把...
  • I_am_a_winer
  • I_am_a_winer
  • 2015-04-03 21:04:56
  • 2142

双向BFS及优化

单向BFS只从起点一端开始搜索,双向BFS则是从起点和终点两边扩展节点,当节点发生重合时即找到最优解。 假设起点到终点深度为d,每个节点平均有n个分支,那么单向BFS需要扩展的节点个数为。而从起点终点...
  • ww32zz
  • ww32zz
  • 2016-02-27 16:33:04
  • 1268

uva1601(双向BFS经典题)

题目描述:http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51163 首先用单向BFS解决,代码如下。最后在单向基础上改进成双...
  • qq_29169749
  • qq_29169749
  • 2016-05-15 23:13:35
  • 2145

BFS、双向BFS和A*

BFS、双向BFS和A* Table of Contents 1. BFS2. 双向BFS3. A*算法 光说不练是没用的,我们从广为人知的POJ 2243这道题谈起:题目大...
  • wdkirchhoff
  • wdkirchhoff
  • 2014-11-14 17:49:34
  • 23216

双向BFS搜索和A*算法

适合给出起点和终点,求最短路径的问题 分别从起点和终点扩展,每次选择待扩展节点少的那个方向进行扩展,扩展一层。然后下一轮。 int doubleBFS(int start, int end, vect...
  • binling
  • binling
  • 2015-12-03 11:22:30
  • 1675
收藏助手
不良信息举报
您举报文章:POJ 1915_双向BFS
举报原因:
原因补充:

(最多只允许输入30个字)