Catch That Cow：BFS：加标记数组：不加标记数组

Catch That Cow

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.

题目描述：找最短步数，用bfs

第一种：含标记数组

#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
int n, k,ans,step[200010],book[200010];		//wa了好几次，这里一定要大一点 ，step：步数 book：标记走没走 
void bfs(int a, int b) {
	ans = 0;
	book[a] = 1;
	queue<int >q;
	q.push(a);
	while (!q.empty()) {
		int x = q.front();
		//cout <<x<<"   "<<b<<"
";
		q.pop();
		if( x== b)break;	
		
		if (x * 2 <= 200010 && x * 2 >= 0 && book[x * 2] == 0) {			//判断边界，判断走没走， 
			book[2 * x] = 1;
			q.push(x * 2);
			step[x * 2] = step[x] + 1;
		}
		if (x + 1 <= 200010 && x + 1 >= 0 && book[x + 1] == 0) {			//判断边界，判断走没走，
			book[1 + x] = 1;
			q.push(x +1);
			step[x + 1] = step[x] + 1;
		}			
		if (x - 1 <= 200010 && x - 1 >= 0 && book[x - 1] == 0) {			//判断边界，判断走没走，
			book[x - 1] = 1;
			q.push(x -1);
			step[x - 1] = step[x] + 1;
		}
	}
}
int main() {
	while (cin >> n >> k) {
		memset(step, 0, sizeof(step));				//不要忘记初始化 
		memset(book, 0, sizeof(book));
	if (n >= k)cout << n - k << endl;				//n不大于k的话  就是n-k了 
	else {
	bfs(n, k);
	cout << step[k] << endl;
	}
	}
	return 0;
}

 

第二种：

不加标记数组，思考了两天了，我一直认为可以不加标记数组，但是提交就wa了，找了两天原因没找到，终于发现了，是我判断的顺序不对，一定要最后判读2*x，否则先判断2*i，后边会越来越大，所以你就不好把握最大值了，并且容易超时，所以先判断x-1　　

判断顺序很重要

#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
int n, k,step[200010];
int bfs(int a, int b) {
	queue<int >q;															//初始化
	memset(step, 0, sizeof(step));
	q.push(a);

	while (!q.empty()) {
		int x = q.front();
		q.pop();

		if (x == b)break;													//找到就终止

		if (x - 1 <= 200010 && x - 1 >= 0 && step[x -1] == 0) {				//这三个顺序很重要，
			q.push(x - 1);
			step[x - 1] = step[x] + 1;
		}
		if (x + 1 <= 200010 && x + 1 >= 0 && step[x +1] == 0) {
			q.push(x + 1);
			step[x + 1] = step[x] + 1;
		}
		if (x * 2 <= 200010 && x * 2 >= 0 && step[x * 2]==0) {				//这个一定要放在最后边
			q.push(x * 2);
			step[x * 2] = step[x] + 1;
		}
	}
	return step[b];
}
int main() {
	while (cin >> n >> k) {

		if (n >= k)															//因为n减小只能-1，所以直接输出就可以
			cout << n - k << endl;
		else 
			cout << bfs(n, k)<< endl;
	}
	return 0;
}