POJ 3287 ——BFS

最新推荐文章于 2025-09-07 20:32:33 发布

转载最新推荐文章于 2025-09-07 20:32:33 发布 · 91 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/mcgrady_ww/p/6638991.html

文章标签：

#java

本文解析了一道名为“CatchThatCow”的算法题，该题目要求使用行走和瞬移两种方式在最短时间内追上静止不动的逃逸奶牛。文章提供了两种解题思路：一种使用两个数组分别记录状态和步数；另一种则仅使用一个数组同时记录状态和步数。通过广度优先搜索算法实现了最优路径的查找。

Catch That Cow

Time Limit: 2000 MS Memory Limit: 65536 KB

64-bit integer IO format: %I64d , %I64u Java class name: Main

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.

Source

USACO 2007 Open Silver

1、用两个数组，一个用于标记状态，一个用来记录步数

#include<bits/stdc++.h>
using namespace std;

queue<int>q;

int vis[100005];
int ans[100005];

int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {

        while(!q.empty())
        {
            q.pop();
        }

        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));

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

        while(!q.empty())
        {
            int tmp = q.front();
            q.pop();
            if(tmp-1>=0&&!vis[tmp-1])//退1
            {
                q.push(tmp-1);
                vis[tmp-1] = 1;
                ans[tmp-1] = ans[tmp] + 1;
            }

            if(tmp+1<=100000&&!vis[tmp+1])//进1
            {
                q.push(tmp+1);
                vis[tmp+1] = 1;
                ans[tmp+1] = ans[tmp] + 1;
            }

            if(tmp*2<=100000&&!vis[tmp*2])//跳跃
            {
                q.push(tmp*2);
                vis[tmp*2] = 1;
                ans[tmp*2] = ans[tmp] + 1;
            }
            if(vis[k])//找到
            {
                break;
            }

        }
    printf("%d\n",ans[k]-1);
    }
    return 0;
}

2、也可以只用一个数组同时标记状态和记录步数

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<queue>
using namespace std;

queue<int>q;
int vis[100005];

int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        while(!q.empty())
        {
            q.pop();
        }
        memset(vis,0,sizeof(vis));
        q.push(n);
        vis[n]=1;
        while(!q.empty()){
        int a=q.front();
        q.pop();
        if(a-1>=0&&!vis[a-1])
        {
            q.push(a-1);
            vis[a-1]=vis[a]+1;
        }///退1
        if(a+1<=100000&&!vis[a+1])
        {
            q.push(a+1);
            vis[a+1]=vis[a]+1;
        }///进1
        if(a*2<=100000&&!vis[2*a])
        {
            q.push(2*a);
            vis[2*a]=vis[a]+1;
        }///跳跃
        if(vis[k])
        {
            break;
        }///找到
        }
        printf("%d\n",vis[k]-1);
    }

    return 0;
}