[PKU暑课笔记] 广度优先搜索BFS POJ3278抓住那头牛 POJ3984迷宫问题

一●引入POJ3278 Catch That Cow http://poj.org/problem?id=3278

题意：农夫知道一头牛的位置，想要抓住它。农夫和牛都位于数轴上，农夫起始位于点N(0<=N<=100000)，牛位于点K(0<=K<=100000)。

农夫有两种移动方式：

1、从X移动到X-1或X+1，每次移动花费一分钟

2、从X移动到2*X，每次移动花费一分钟

假设牛没有意识到农夫的行动，站在原地不动。农夫最少要花多少时间才能抓住牛？

假设农夫起始位于点3，牛位于5，N=3，K=5，最右边是6。

如何搜索到一条走到5的路径？

策略1）深度优先搜索：从起点出发，随机挑一个方向，能往前走就往前走(扩展），走不动了则回溯。不能走已经走过的点（要判重）。

运气好的话：3->4->5或3->6->5

运气不太好的话：3->2->4->5

运气最坏的话：3->2->1->0->4->5

要想求最优（短）解，则要遍历所有走法。可以用各种手段优化。

比如，若已经找到路径长度为n的解，则所有长度大于n的走法就不必尝试。

运算过程中需要存储路径上的节点，数量较少。用栈存节点。

策略2）广度优先搜索：给节点分层。起点是第0层。从起点最少需n步就能到达的点属于第n层。

第1层：2,4,6 第2层：1,5 第3层：0

依层次顺序，从小到大扩展节点。把层次低的点全部扩展出来后，才会扩展层次高的点。

不能走已经走过的点（要判重）。

可确保找到最优解，但是因扩展出来的节点较多，且多数节点都需要保存，因此需要的存储空间较大。

用队列存节点。

算法细节：（用QUEUE）

(1) 把初始节点S0放入Open表中；

(2) 如果Open表为空，则问题无解，失败退出；

(3) 把Open表的第一个节点取出放入Closed表，并记该节点为n；

(4) 考察节点n是否为目标节点。若是，则得到问题的解，成功退出；

(5) 若节点n不可扩展，则转第(2)步；

(6) 扩展节点n，将其不在Closed表和Open表中的子节点（判重）放入Open表的尾部，

并为每一个子节点设置指向父节点的指针(或记录节点的层次），然后转第(2)步。

广度优先搜索队列变化过程：

(1)把初始节点放入Open表中

(3)把Open表的第一个节点取出放入Closed表，并记该节点为n

(4)(6)==>节点n不是目标节点，扩展节点n，将其不在Closed表和Open表中的子节点判重，放入Open表的尾部
并为每一个子节点设置指向父节点的指针（或记录节点的层次）

(6)

(6)

(6)

(4) 考察节点n是否为目标节点。若是，则得到问题的解，成功退出；

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;

int n,k;
const int MAXN=100010;
int visited[MAXN];//判重标记，visited[i]=true表示i已经拓展过
struct step
{
    int x;//位置
    int steps;//到达x所需的步数
    step(int xx,int s):x(xx),steps(s) {}
};
queue<step>q;//队列（Open表）

int main()
{
    cin>>n>>k;
    memset(visited,0,sizeof(visited));
    q.push(step(n,0));
    visited[n]=1;
    while(!q.empty())
    {
        step s=q.front();
        if(s.x==k)//找到目标
        {
            cout<<s.steps<<endl;
            return 0;
        }
        else
        {
            if(s.x-1>=0 && !visited[s.x-1])
            {
                q.push(step(s.x-1,s.steps+1));
                visited[s.x-1]=1;
            }
            if(s.x+1<=MAXN && !visited[s.x+1])
            {
                q.push(step(s.x+1,s.steps+1));
                visited[s.x+1]=1;
            }
            if(s.x*2<=MAXN&&!visited[s.x*2])
            {
                q.push(step(s.x*2,s.steps+1));
                visited[s.x*2]=1;
            }
            q.pop();
        }
    }
    return 0;
}

二●迷宫问题及变形POJ3984 迷宫问题 http://poj.org/problem?id=3984

1)广搜

2)不能使用STL的queue，要自己用数组来实现队列

3)新的节点要进入队列时，需在该节点内部用father指针记录其父节点在队列中的下标（到达迷宫中某个位置的时候，要记录刚才是从哪个位置过来的）

4)当目标节点出队列时，沿着节点的father指针链，就能倒着找到从起点到目标的路径