HDU 2717 Catch That Cow

最新推荐文章于 2022-10-16 04:57:01 发布

Gusugureng

最新推荐文章于 2022-10-16 04:57:01 发布

阅读量560

点赞数 1

CC 4.0 BY-SA版权

分类专栏： bfs 文章标签： bfs

本文链接：https://blog.youkuaiyun.com/Gusugureng/article/details/68953745

bfs 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一个基于广度优先搜索(BFS)算法解决的趣味问题：如何在一个数轴上，利用步行与瞬间传送两种方式最快地追上一只静止不动的逃逸奶牛。文章提供了详细的解题思路与完整的Java实现代码。

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

 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.

题目大意：一个东西追另外一个东西，他可以有三种办法移动，坐标+1，-1，或*2.
解体思路：bfs
注意点：k可能<=N,此时答案是K-N+1，坐标只有在小于k时才能*2，否则数组必然越界，而且没有意义，即需做一定剪枝。
java代码

import java.util.*;
import java.math.*;
public class Main{
    public static class pair{
        public  int first,second;
        public pair(int a,int b){
            first=a;
            second=b;
        }
        public pair(){

        }
        }
        public static pair make_pair(int a,int b){
            pair w=new pair(a,b);
            return w;
        }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int N,K;
        while(in.hasNext()){
            N=in.nextInt();
            K=in.nextInt();
            boolean []vist=new boolean[Math.max(2*N+3,2*K+3)];
            Queue<pair> qu=new LinkedList<pair>();
            qu.offer(make_pair(N,0));
            vist[N]=true;
            while(!qu.isEmpty()){
                int p=qu.peek().first;
                int ans=qu.peek().second;
                qu.poll();
                if(p==K){
                    System.out.println(ans);
                    break;
                }
                ans++;
                if(!vist[p+1]&&p<K){
                    qu.offer(make_pair(p+1,ans));
                    vist[p+1]=true;
                }
                if(p>=1&&!vist[p-1]){
                    qu.offer(make_pair(p-1,ans));
                    vist[p-1]=true;
                }
                if(p<K&&!vist[2*p]){
                    qu.offer(make_pair(2*p,ans));
                    vist[p*2]=true;
                }
        }
    }
    }
}