POJ 3278 Catch That Cow

Catch That Cow

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 48127		Accepted: 15077

Description

Farmer John has been informed of the location of a fugitive cow and wants to catch her immediately. He starts at a point N (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 or X + 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.

 

  算法分析：bfs的一道搜索题目，一开始我以为应该是去找到某种 统一的算法公式来计算从 “起点数字” 到“终点数字”的最小步骤数，

                    可是想了半天都没有思路，最后想到了暴力解决问题。

             可这不是bfs的算法题吗？

             不错，并非是普通的线性暴力搜索，需要用到bfs的思想。仔细分析便可知道，计算机程序做不到动态的决定从当前的这一

             步该怎样继续走下去 所达到的结果最优！（只限在本题）

             所以我们的思路就是：从“当前节点”出发，可以到到其余3个节点，这三个节点又可以分别到达3个节点，加起来就是9个点了，

             当然这9个点可能会出现重复的点，也就是说，如果该点已经被访问过了，也就没有再访问的必要了。所以要用到标记术数组。

             如此继续下去，判断每一个可到达的点是不是终点即可，如果该点是 终点，返回 到达“当前节点”的步数统计数（用数组来记录）。

    

           

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;
int vis[101000], dis[101000];

int bfs(int n, int k)
{
    queue<int>q; //简历队列
    q.push(n); //将起点入队列
    vis[n]=1; //标记起点被访问
    dis[n]=0; //此时起点到自身的步数为0
    int curpos; //当前节点

    while(!q.empty() ) //判断队列不为空
    {
        curpos=q.front();  //取出当前队首元素
        q.pop(); 
        
        if(curpos == k) //如果等于终点
        {
            return dis[curpos];  //返回步数
        }
        else
        {
            if(curpos-1>=0 && curpos<=100000 && vis[curpos-1]==0 ) //判断此点是否可行
            {
                q.push(curpos-1);  //如果行，进入队列 待命
                vis[curpos-1]=1;   //标记该点被访问,以后不要被重复访问了
                dis[curpos-1]=dis[curpos]+1; // 到达此点的步数 == 当前点的步数+1
            }
            if(curpos+1>=0 && curpos+1<=100000 && vis[curpos+1]==0 ) //类推
            {
                q.push(curpos+1);
                vis[curpos+1]=1;
                dis[curpos+1]=dis[curpos]+1;
            }
            if(curpos*2>=0 && curpos*2<=100000 && vis[curpos*2]==0 ) //类推
            {
                q.push(curpos*2);
                vis[curpos*2]=1;
                dis[curpos*2]=dis[curpos]+1;
            }
        }
    }
    return 0;
}

int main()
{
    int n, k;
    while(scanf("%d %d", &n, &k)!=EOF)
    {
        memset(vis, 0, sizeof(vis));
        memset(dis, 0, sizeof(dis));

        printf("%d
", bfs(n, k));
    }
    return 0;
}

   第二次的写法：

    

#include <iostream>
#include <string>
#include <stdio.h>
#include <string.h>
#include <queue>
#define INF 99999999

using namespace std;
int vis[100001];
int dis[100001];

int bfs(int n, int k)
{
    memset(vis, 0, sizeof(vis));
    memset(dis, 0, sizeof(dis));
    queue<int>q;

    q.push(n);
    vis[n]=1;
    dis[1]=0;

    int dd;
    while(!q.empty())
    {
        dd=q.front();
        q.pop();

        if(dd==k)
        {
            return dis[dd];
        }
        else
        {
            if( !vis[dd+1] && dd+1>=0 && dd+1<=100000 )
            {
                q.push(dd+1);
                dis[dd+1]=dis[dd]+1;
                vis[dd+1]=1;
            }
            if( !vis[dd-1] && dd-1>=0 && dd-1<=100000 )
            {
                q.push(dd-1);
                dis[dd-1]=dis[dd]+1;
                vis[dd-1]=1;
            }
            if(!vis[dd*2] && dd*2>=0 && dd*2<=100000 )
            {
                q.push(dd*2);
                dis[dd*2]=dis[dd]+1;
                vis[dd*2]=1;
            }
        }
    }
    return 0;   // 开始忘记 写这个指令了，跑出来的结果很像随机 结果！  不知道为什么，加上之后就运行正确了 ！
}！

int main()
{
    int n, k;
    int dd;
    while(cin>>n>>k)
    {
        dd = bfs(n, k);
        cout<<dd<<endl;
    }
    return 0;
}