catch that cow

问题描述：

农夫想去找回他丢失的牛。设农夫当前的位置为N，牛的位置为K。农夫和牛都在数轴上。农夫有两种移动方式：

1.从X移动到X+1或X-1，花费的时间为1 min；

2.从X移动到X*2,花费的时间为1 min；

假设牛不会移动，求农夫最少需要多长时间才能抓到牛。

输入要求：

一行，分别为N和K；

输出要求：

一行，为农夫抓到牛所花费的最短时间。

Example:

input:

5 17

output:

4

农夫想抓到牛，可以通过5->10（X*2）->9(X-1)->18(X*2)->17(X-1)的移动方式。

思路分析：

农夫的两种移动方式，所花费的时间都是一样的，并且我们要求最短时间，因此可以考虑用BFS的方法来实现。农夫的每一次移动，如果没有到达目的地（牛所在的位置），那么都可以将他下一步可能的移动方式X+1, X-1, X*2加入队列，并再作比较。

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int K = in.nextInt();
        int result = bfs(N, K);
        System.out.println(result);
    }
    
    public static int bfs(int n, int k) {
        int[] steps = new int[100005];
        boolean[] visited = new boolean[100005];
        int[] queue = new int[100005];
        int head = 0;
        int tail = 0;
        steps[n] = 0;
        visited[n] = true;
        queue[tail++] = n;
        int[] dx = {1, -1};
        while(head < tail) {
            int curPoint = queue[head++];
            for(int i = 0; i < 2; i++) {
                int x = curPoint + dx[i];
                if(x >= 0 && x <= 100000 && !visited[x]) {
                    steps[x] = steps[curPoint] + 1;
                    visited[x] = true;
                    queue[tail++] = x;
                }
                if(x == k) {
                    return steps[k];
                }
            }
            int x = curPoint * 2;
            if(x >= 0 && x <= 100000 && !visited[x]) {
                steps[x] = steps[curPoint] + 1;
                visited[x] = true;
                queue[tail++] = x;
            }
            if(x == k) {
                return steps[k];
            }
        }
        return steps[k];
    }

}

尝试用C++写了一下并比较一下性能，天，差别够大

#include <iostream>
#define Max 100005
using namespace std;

int steps[Max];
int queue[Max];
bool visited[Max];
int N, K;
int bfs();

int main()
{
    cin >> N >> K;
    int result = bfs();
    cout << result << endl;
    return 0;
}

int bfs(){
    steps[N] = 0;
    int head = 0;
    int tail = 0;
    queue[tail++] = N;
    visited[N] = true;
    int dx[] = {1, -1};
    while(head < tail){
        int curPoint = queue[head++];
        int x = curPoint*2;
        if(x >= 0 && x <= 100000 && !visited[x]){
            steps[x] = steps[curPoint]+1;
            queue[tail++] = x;
            visited[x] = true;
        }
        if(x == K){
            return steps[K];
        }
        for(int i = 0; i < 2; i++){
            int x_next = curPoint + dx[i];
            if(x_next >= 0 && x_next <= 100000 && !visited[x_next]){
            steps[x_next] = steps[curPoint]+1;
            queue[tail++] = x_next;
            visited[x_next] = true;
            }
            if(x == K){
                return steps[K];
            }
        }
    }
    return steps[K];
}