poj3278 Catch That Cow

[align=center]Catch That Cow[/align]

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.*;

pu
95fe
blic 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
= 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;
}
}

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