BFS-Prime Path POJ - 3126

BFS-Prime Path POJ - 3126

The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.
— It is a matter of security to change such things every now and then, to keep the enemy in the dark.
— But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!
— I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.
— No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!
— I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.
— Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.

Now, the minister of finance, who had been eavesdropping, intervened.
— No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.
— Hmm, in that case I need a computer program to minimize the cost. You don’t know some very cheap software gurus, do you?
— In fact, I do. You see, there is this programming contest going on… Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above.
1033
1733
3733
3739
3779
8779
8179
The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.
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

题意：
给定2个四位素数L和R（L<=R），每次可改变L四位上的一个数字，使得L变成另外一个素数，前缀不能为0。
问：最少通过几步能够使得L等于R。
思路：

1. 欧拉筛预处理标记1-10000之间的所有素数
2. 求最短路，枚举每个数位的选择：0(1)~9种不同的选择，若是素数就进队，层次+1。

#include <cstdio>
#include <queue>
#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
bool is_prime[10005];
int st, ed, n, vis[10005];
int help[4] = {1, 10, 100, 1000};//对四位数字单独枚举操作
struct node {
	int num, step;//num为枚举的素数，step为当前所在层次（操作次数）
	node(int num, int step): num(num), step(step){}
};

void Euler()//欧拉筛
{
    memset(is_prime,true,sizeof(is_prime));
    is_prime[0]=is_prime[1]=false;
	for (int i = 2; i<= int(sqrt(10000)); i++)
    {
		if (is_prime[i])
		{
			for (int j = i * i; j <= 10000; j += i)
            {
				is_prime[j] = false;
			}
		}
	}
}

int bfs() {
	queue<node> q;
	q.push(node(st, 0));
	vis[st] = 1;//vis优化-走过的路不重复走
	while (q.size()) {
		node t = q.front();//临时变量取队首素数操作
		q.pop();
		//模拟下状态
		for (int i = 0; i < 4; i++) {
			//修改数字
			int tem;//临时变量计算当前枚举的数
			for (int j = (i == 3 ? 1 : 0); j <= 9; j++) {
				tem = j*help[i] + (t.num - (t.num / help[i] % 10) * help[i]);//枚举第i位上可能的数值j，先将t.num第i位的值减去，再加
				if (!is_prime[tem] || vis[tem]) continue;
				q.push(node(tem, t.step + 1));
				vis[tem] = 1;
				if (tem == ed) return t.step + 1;
			}
		}
	}
	return -1;
}

int main() {
	Euler();
	scanf("%d", &n);
	while (n--) {
		memset(vis, 0, sizeof vis);
		scanf("%d%d", &st, &ed);
		if (st == ed) {
			printf("0\n");
			continue;
		}
		int t = bfs();
		if (t != -1)
			printf("%d\n", t);
		else
		printf("Impossible\n");
	}
	return 0;
}

总结：

1. 欧拉筛板子敲得还不够熟练
2. 写广搜时先不要管优化太多不必要的情况，首先定义对应的结构体：关键字值和层次。接着按套路枚举每个值(点)各种拓展的可能性(连通的路径)，将符合条件的可能性进队并更新层次，同时数组标记，避免重复搜索。
3. 值相等**(走到终点)时return**。