Hdu2717 Catch That Cow(BFS) ---Java版

Catch That Cow

Time Limit: 5000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 13472 Accepted Submission(s): 4143

Problem 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

  
  

   
   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.
   
   
  
  

题意：将给定的数字n通过 +1、-1、*2 变为k，输出最小变换次数。

思路：BFS即可，Java的BFS不太熟悉，开始打算用List记录访问过的数字，可是超时了，看来还是要用数组标记。队列要自己写，结构体换成类，入队列可以用构造传参。

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       while(sc.hasNext()){
    	   int n = sc.nextInt();
    	   int k = sc.nextInt();
    	   int sum=0;
    	   sum = bfs(n,k);
    	   System.out.println(sum);
       }
	}

	public static int bfs(int n, int k) {
		Queue que = new Queue();
    	   Node node = new Node();
    	   Boolean vis[] = new Boolean[200001];
    	   for(int i=0;i<vis.length;i++){
    		   vis[i]=false;
    	   }
    	   int sum=0;
    	   node.step=0;
    	   node.num=n;
    	   que.push(node);
    	   vis[n]=true;
    	   while(que.size()>0){
    		   Node temp = (Node) que.pop();
    		   
    		    if(temp.num==k){
    		    	sum=temp.step;
    		    	break;
    		    }
    		    
    		  int t = temp.num;
    		  if(t-1>=0 && !vis[t-1]){
    			  Node te = new Node();
    			  te.num=t-1;
    			  te.step=temp.step+1;
    			  que.push(te);
    			  vis[te.num]=true;
    		  }
    		  
    		  if(t+1<200000 && !vis[t+1]){
    			  Node te = new Node();
    			  te.num=t+1;
    			  te.step=temp.step+1;
    			  que.push(te);
    			  vis[te.num]=true;
    		  }
    		  
    		  if(2*t<200000&&!vis[2*t]){
    			  Node te = new Node();
    			  te.num=t*2;
    			  te.step=temp.step+1;
    			  que.push(te);
    			  vis[te.num]=true;
    		  }
    	   }
		return sum;
	}

}
class Queue{
	List list = new ArrayList();
	
	public void push(Object obj){
		list.add(obj);
	}
	
	public Object pop(){
		if(list.size()>0){
			return list.remove(0);
		}else{
			return null;
		}
	}
	
	public int size(){
		return list.size();
	}
}
class Node{
	int num;
	int step;
}