poj 3278 Catch That Cow

原题：
Catch That Cow
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 172001 Accepted: 52611

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.

Source
USACO 2007 Open Silver

中文：

在一个数轴上，你要抓一头牛，你在n点，牛在k点，你可以一次向前走1步，或者向后走一步，或者向前走当前位置的两倍，问你最少走多少步抓到牛（牛不动）

代码：

#include <iostream>
#include <vector>
#include <iterator>
#include <string>
#include <algorithm>
#include <cstring>
#include <limits>
#include <queue>
#include <functional>
using namespace std;
const int maxn = 200000 + 1;
typedef long long ll;

struct node
{
	int step;
	int pos;
};
int n, k;
int ans,tmp;
bool vis[maxn];

int bfs(int st,int ed)
{

	memset(vis, 0, sizeof(vis));
	queue<node> Q;
	Q.push({ 0,st });
	vis[n] = 1;
	while (!Q.empty())
	{
		node head = Q.front();
		Q.pop();
		if (head.pos - 1 >= 0 && !vis[head.pos - 1])
		{
			if (head.pos - 1 == ed)
			{
				return head.step + 1;
			}
			vis[head.pos - 1] = true;
			Q.push({head.step + 1, head.pos - 1});
		}
		if (head.pos + 1 <= ed * 2 && !vis[head.pos + 1])
		{
			if (head.pos + 1 == ed)
			{
				return head.step + 1;
			}
			vis[head.pos + 1] = true;
			Q.push({ head.step + 1, head.pos + 1 });
		}
		if (head.pos * 2 <= ed * 2 && !vis[head.pos * 2])
		{
			if (head.pos * 2 == ed)
			{
				return head.step + 1;
			}
			vis[head.pos * 2] = true;
			Q.push({ head.step + 1, head.pos * 2 });
		}
	}
	return 0;
}

int main()
{
	ios::sync_with_stdio(false);
	while (cin >> n >> k)
	{
		ans = bfs(n, k);
		cout << ans << endl;
	}
	return 0;
}

用dp

#include <iostream>
#include <vector>
#include <iterator>
#include <string>
#include <algorithm>
#include <cstring>
#include <limits>
#include <queue>
#include <functional>
using namespace std;
const int maxn = 200000 + 1;
typedef long long ll;

int n, k;

int dp[maxn];
int main()
{
	ios::sync_with_stdio(false);
	while (cin >> n >> k)
	{
		memset(dp, 0, sizeof(dp));
		for (int i = 0; i <= k; i++)
		{
			dp[i] = abs(i - n);
		}
		for (int i = n + 1; i <= k; i++)
		{
			if (i % 2 == 0)
			{
				dp[i] = min(dp[i], dp[i / 2] + 1);
				dp[i] = min(dp[i], dp[i - 1] + 1);
			}
			else
			{
				dp[i] = min(dp[i], dp[(i-1) / 2] + 2);
				dp[i] = min(dp[i], dp[i - 1] + 1);
				dp[i] = min(dp[i], dp[(i + 1) / 2] + 2);
			}
		}
		cout << dp[k] << endl;
	}
	return 0;
}

思路：

其实是一道很明显的线性dp问题，在kb大神的练习场中标着搜索专题。就用搜索的方法来做，使用广搜来寻找最小值，每次记录当前位置的最小值，达到终点后直接返回即可。

如果使用dp，要分奇偶判断进行状态转移，还是很简单的。