[搜索] POJ 3278 Catch that Cow 广搜的讨论

Catch That Cow

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 45556		Accepted: 14277

Description

Farmer John has been informed of the location of a fugitive cow and wants to catch her immediately. He starts at a pointN (0 ≤N ≤ 100,000) on a number line and the cow is at a point K (0 ≤ K ≤ 100,000) on the same number line. Farmer John has two modes of transportation: walking and teleporting.

* Walking: FJ can move from any point X to the points X - 1 orX+ 1 in a single minute
* Teleporting: FJ can move from any point X to the point 2 × X in a single minute.

If the cow, unaware of its pursuit, does not move at all, how long does it take for Farmer John to retrieve it?

Input

Line 1: Two space-separated integers: N and K

Output

Line 1: The least amount of time, in minutes, it takes for Farmer John to catch the fugitive cow.

Sample Input

5 17

Sample Output

4

Hint

The fastest way for Farmer John to reach the fugitive cow is to move along the following path: 5-10-9-18-17, which takes 4 minutes.

 

翻译：

农夫知道一头牛的位置，想要抓住它。农夫和牛都位于数轴上，农夫起始位于点N(0<=N<=100000)，牛位于点K(0<=K<=100000)。农夫有两种移动方式：
1、从X移动到X-1或X+1，每次移动花费一分钟。
2、从X移动到2*X，每次移动花费一分钟。
假设牛没有意识到农夫的行动，站在原地不动。农夫最少要花多少时间才能抓住牛？

样例说明：农夫从5到17的最快走法是这样: 5 - 10 - 9 - 18 - 17 ，总共4分钟。

 

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

  

 

广度优先搜索

给节点分层。起点是第0层。从起点最少需n步就能到达的点属于第n层。依层次顺序，从小到大扩展节点。把层次低的点全部扩展出来后，才会扩展层次高的点。扩展时，不能扩展出已经走过的节点(要判重）。可确保找到最优解，但是因扩展出来的节点较多，且多数节点都需要保存，因此需要的存储空间较大。用队列存节点。

广度优先搜索算法如下：（用QUEUE）
(1) 把初始节点S0放入Open表中；
(2) 如果Open表为空，则问题无解，失败退出；
(3) 把Open表的第一个节点取出放入Closed表，并记该节点为n；
(4) 考察节点n是否为目标节点。若是，则得到问题的解，成功退出；
(5) 若节点n不可扩展，则转第(2)步；
(6) 扩展节点n，将其不在Closed表和Open表中的子节点(判重）放入Open表的尾部，并为每一个子节点设置指向父节点的指针(或记录节点的层次），然后转第(2)步。

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;
int N,K;
const int MAXN=100000;
int vis[MAXN+10]; //判重
struct Step
{
    int x; //位置
    int steps; //到达终点所需要的步数
    Step(int xx,int s){x=xx;steps=s;}
};
queue<Step> q;
int main()
{
    cin>>N>>K;
    memset(vis,0,sizeof(vis));
    q.push(Step(N,0)); //入栈
    vis[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 && !vis[s.x-1])
                {
                    q.push(Step(s.x-1,s.steps+1));
                    vis[s.x-1]=1;
                }
                if(s.x+1<=MAXN && !vis[s.x+1])
                {
                    q.push(Step(s.x+1,s.steps+1));
                    vis[s.x+1]=1;
                }
                if( s.x * 2 <= MAXN &&!vis[s.x*2] )
                {
                    q.push(Step(s.x*2,s.steps+1));
                    vis[s.x*2] = 1;
                }
                q.pop();
            }
    }
    return 0;
}

这个题目有点像一维的迷宫，这样看起来，如果数据量不是太大(bfs内存能放得下)，那么用bfs是比dfs好太多太多的