POJ3126 Prime Path（BFS）

题目链接：POJ 3126
题意：每一组测试数据给定2个4位数的素数（第一位不为0），如1033，8179，要求每次只能变化一位，求从1033变化到8179需要多少步？这种情况的方案如下，需要6步

1033
1733
3733
3739
3779
8779
8179

Input
One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).

Output
One line for each case, either with a number stating the minimal cost or containing the word Impossible.

Sample Input
3
1033 8179
1373 8017
1033 1033

Sample Output
6
7
0

思路： 假设输入两个4位的素数分别为start，end。每次只能改变一位，搜索从start到end的路径。首先可以想象以起始数start为根节点（设根节点所在树的高度为0），所有树高为1的子节点为根节点变化1位后的所有可能的素数，以此类推，每个节点都是素数并且是由其父节点变化一位得到（但是不能重复，如一个素数在第1层出现，此后都不再出现）。

上面的搜索问题要求最短的路径，按层次遍历这颗树（用到BFS），如果有一条从根start到end节点的路径，则访问到end节点时结束遍历，end节点所在的高度就是从start到end的路径长度，从根节点到end节点路径上的节点就是每次变化过程的数。

代码

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <cstdio>
using namespace std;
const int N = 10010;
bool prime[N];//如果i是素数那么prime[i]为true
int steps[N];//steps[i]存储从start到i的步数
bool visited[N];//如果i被访问过，则visited[i]为true

void filter_prime() {//筛法求素数
	for (int i = 0; i < N; i++) prime[i] = true;
	prime[0] = false; prime[1] = false;
	for (int i = 2; i < N; i++) {
		if (prime[i]) {//如果i是素数，将所有是i的倍数的数删去
			for (int j = 2; j * i < N; j++) {//j为i的倍数
				prime[j * i] = false;
			}
		}
	}
}

bool bfs(int start, int ends) {
	int step = 0;
	queue<int> Q;
	Q.push(start);
	visited[start] = true;
	int nums[4];//存储start的4位数
	while (!Q.empty()){
		int start = Q.front();
		Q.pop();
		nums[0] = start / 1000;
		nums[1] = start / 100 % 10;
		nums[2] = start / 10 % 10;
		nums[3] = start % 10;
		for (int i = 0; i < 4; i++) {//对每一位尝试改变
			for (int j = 0; j < 10; j++) {
				if (i == 0 && j == 0 || j == nums[i]) continue;//第一位不能为0, 不同才改变
				int t = nums[i];
				nums[i] = j;
				int num = nums[0] * 1000 + nums[1] * 100 + nums[2] * 10 + nums[3];//将改变后的数合成
				if (prime[num] && !visited[num]) {//如果num是素数并且没有被访问过
					Q.push(num);
					visited[num] = true;
					steps[num] = steps[start] + 1;
					//printf("steps[%d] = %d\n", num, step + 1);
					if (num == ends) {
						return 1;
					}
				}
				nums[i] = t;
			}
		}
		step++;
	}
	return false;
}


int main() {
	filter_prime();
	int test_cases;
	cin >> test_cases;
	while (test_cases--) {
		memset(steps, 0, sizeof(steps));
		memset(visited, false, sizeof(visited));
		int start, ends;
		cin >> start >> ends;
		if (start == ends) { 
			cout << 0 << endl; 
			continue;
		}
		int flag = bfs(start, ends);
		if (flag) cout << steps[ends] << endl;
		else cout << "Impossible" << endl;
	}

	return 0;
}