poj3278 Catch That Cow

Catch That Cow

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 86354		Accepted: 27100

Description

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

Source

USACO 2007 Open Silver

思路：我的第一个用广度优先搜索完成的题目，认识到广度优先搜索在寻找最优解时时间的节约性。代码用java写的，用到了util包中的队列类，先说说用的类和方法吧。

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

使用的是LinkedList，泛型呢，是自己写的符合题目要求的一个step类，里面定义了两个变量，一个是当前位置坐标，另外一个是记录了当前是多少步走到这里，还用到了队列的几个方法，如下：

boolean

add(E e) Appends the specified element to the end of this list.

E	poll() Retrieves and removes the head (first element) of this list.

int	size() Returns the number of elements in this list.

import java.util.*;

public class Main {
	
	public static final int MAXLEN = 100000;
	static boolean[] visited;
	static int N,K;
	
	public static void main(String[] args) {
		visited = new boolean[MAXLEN+5];
		Arrays.fill(visited, false);
		Scanner input = new Scanner(System.in);
		N = input.nextInt();
		K = input.nextInt();
		Queue<step> queue = new LinkedList<step>();
		visited[N] = true;
		queue.add(new step(N,0));
		while( queue.size() != 0){	//判断队列是否为空
			step s = queue.poll();	//从队列头弹出一个step变量
			if( s.x == K ){
				System.out.println(s.count_step);	//是K，跳出循环
				break;
			}else {
				if( s.x > 0 && !visited[s.x-1]){	//向左走
					queue.add(new step(s.x-1,s.count_step+1));
					visited[s.x-1] = true;
				}
				if( s.x < 100000 && !visited[s.x+1]){//向右走
					queue.add(new step(s.x+1,s.count_step+1));
					visited[s.x+1] = true;
				}
				if( 2 * s.x <= 100000 && !visited[2*s.x]){	//跳着走
					queue.add(new step(2*s.x,s.count_step+1));
					visited[2*s.x] = true;
				}
			}
		}
	}
}
class step{
	int x;
	int count_step;
	public step(int x,int count_step){
		this.x = x;
		this.count_step = count_step;
	}
}

通过这个简单例子，学习了队列的简单使用。