poj 3278 Catch That Cow (bfs搜索）

最新推荐文章于 2021-08-11 07:01:00 发布

原创最新推荐文章于 2021-08-11 07:01:00 发布 · 2.3k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#acm #poj #bfs

ACM刷题录同时被 3 个专栏收录

112 篇文章

订阅专栏

poj

28 篇文章

订阅专栏

搜索

13 篇文章

订阅专栏

本文介绍了一种使用广度优先搜索（BFS）算法解决农夫FJ抓逃牛问题的方法，详细解释了算法思路，并提供了代码实现。通过分析问题特点，巧妙地将问题转化为BFS问题，最终高效地找到了逃牛的位置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Catch That Cow

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 46715		Accepted: 14673

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

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.

开始看到这道题觉得和以前做的一道题很像，那道题直接用暴力做，一直判断是否可以整除2就行了，然后一开始也想用暴力去做，但是后来做的有些情况就考虑不到，这个题目也比那个题目复制 http://blog.youkuaiyun.com/whjkm/article/details/26985421 （以前那道题目的链接），后来仔细看了一下题，跟那道题还是有比较大的差别，那个题目简单就在于，它的起点是从0开始的，不能往后退；这个题目就有三种情况，向前进1，向后减1，使用传送向前进2倍的距离。开始也想不到要用bfs，看到了这个题目的分类是bfs，然后采用bfs来做。

这个题目的主要的思路就是 3 入口的bfs，先把第一个点的3种情况入队，标记这个点已经访问，再把下一个位置的3种情况入队，这里也有剪枝，（剪枝参考别人的）效率提高了不少，直到找到最终的那个点。

下面是代码，用数组模拟队列；

#include <cstdio>
#include <cstring>
const int maxn=200030;
typedef struct Queue //一个结构体，保存这个点的位置，和到这个点所用的时间
{
    int count,step;
}Queue;
Queue queue[maxn];//队列数组
int visit[maxn];//访问数组
void bfs(int n,int k)
{
    int front=0,rear=0;
    queue[rear].step=n;//把初始位置入队
    queue[rear++].count=0;
    visit[n]=1;//标记访问
    while(front<rear)
    {
        Queue q=queue[front++];
        if(q.step==k)//找到终点位置
        {
            printf("%d\n",q.count);
            break;
        }
        if(q.step-1>=0 && !visit[q.step-1])//注意剪枝的条件，一定要注意可以等于0
        {
            visit[q.step]=1;
            queue[rear].step=q.step-1;//向后寻找一位
            queue[rear++].count=q.count+1;//时间+1
        }
        if(q.step<=k && !visit[q.step+1])//剪枝
        {
            visit[q.step+1]=1;
            queue[rear].step=q.step+1;//向前寻找一位
            queue[rear++].count=q.count+1;
        }
        if(q.step<=k && !visit[q.step*2])//剪枝
        {
            visit[q.step*2]=1;//传送的情况
            queue[rear].step=q.step*2;
            queue[rear++].count=q.count+1;
        }
    }
}
int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        memset(visit,0,sizeof(visit));
        bfs(n,k);
    }
    return 0;
}

也可以用STL写，效率就没有自己手动写的高，还有标记数组用bool比较节省内存；

我自己用STL又写了一次，思路和上面的一样；

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int maxn=200030;
queue<int>q;
int Count[maxn];
bool visit[maxn];
void bfs(int n,int k)
{
   q.push(n);
   visit[n]=1;
   Count[n]=0;
   while(!q.empty())
   {
       int x=q.front();
       q.pop();
       if(x==k)
       {
           printf("%d\n",Count[x]);
           break;
       }
       if(x-1>=0 && !visit[x-1])
       {
           q.push(x-1);
           visit[x-1]=1;
           Count[x-1]=Count[x]+1;
       }
       if(x<=k && !visit[x+1])
       {
           q.push(x+1);
           visit[x+1]=1;
           Count[x+1]=Count[x]+1;
       }
        if(x<=k && !visit[2*x])
       {
           q.push(x*2);
           visit[x*2]=1;
           Count[x*2]=Count[x]+1;
       }
   }
}
int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        memset(visit,0,sizeof(visit));
        bfs(n,k);
    }
    return 0;
}

看到别人的一种写法，貌似也不错，分三个方向进行搜索

#include <iostream>
#include <queue>
#define SIZE 100001

using namespace std;

queue<int> x;
bool visited[SIZE];
int step[SIZE];

int bfs(int n, int k)
{
int head, next;
//起始节点入队
x.push(n);
//标记n已访问 
visited[n] = true;
//起始步数为0 
step[n] = 0;
//队列非空时 
while (!x.empty())
{
//取出队头 
head = x.front();
//弹出队头 
x.pop();
//3个方向搜索 
for (int i = 0; i < 3; i++)
{
if (i == 0) next = head - 1;
else if (i == 1) next = head + 1;
else next = head * 2;
//越界就不考虑了 
if (next > SIZE || next < 0) continue;
//判重 
if (!visited[next])
{
//节点入队 
x.push(next);
//步数+1 
step[next] = step[head] + 1;
//标记节点已访问 
visited[next] = true;
}
//找到退出 
if (next == k) return step[next];
}
}
}

int main()
{
int n, k;
cin >> n >> k;
if (n >= k)
{
cout << n - k << endl;
}
else
{
cout << bfs(n, k) << endl;
}
return 0;
}