poj3126怪癖首相（广搜）

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

题解：一直以为广搜就是跟图联系在一起的，看到这题就没能马上跟bfs联系在一起。搜了别人的题解才多了些感悟，广搜只要有方向给他搜让它能够搜下去就可以了，题目说每次只能改变一个数字，那四位数字不就可以看成四个方向了吗，不同的是在这个方向上有多种可能，因为一个数字是可以0-9的，而且需要注意的是每搜完一个方向要把这个数字复原，因为每次变只能变一个数字。弄个变量，要是找到所要的素数就给表1然后结束，但想了很久不知道要是一直搜不到，什么时候结束，最后弄了一个可能比较笨的办法，计算了1000-9999中素数的个数，那把所有已访问的素数都广搜了一遍还是没找到想要的数，则没办法通过每次改变一个数字让他变成想要的。这里也顺便复习了一下找素数的办法：将2-10000的数排列成一列，每次取剩下最小的数（第一次为2），然后把所有与它成倍数的数（即为合数）都剔除，那剩下的数中最小的数即为素数（因为该数如果为合数，那该数可以由比它小的两个小的数相乘，但比它小的数的倍数已经全部剔除了，所有该数肯定不是由比它小的数相乘以整数倍得来的，即不可能为合数）

ac代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <math.h>
#include <cstdlib>
#include <queue>
using namespace std;
int fa[5], judge[10010], ji[10010],t=0;//分别记方向，记素数，记走过的路线。
struct asd
{
	int  y, z;
}p[10010];
void sushu()//记录素数
{
	memset(judge, 0, sizeof(judge));
	judge[0] = judge[1] = 1;
	for (int i = 2; i < 10000; i++)
	{
		if (judge[i] == 0) {
			for (int j = 2; i*j < 10000; j ++)
				judge[j*i] = 1;
		}
	}

}
int bfs(int a, int b)
{
	memset(ji, 0, sizeof(ji));
	int n = 0, m = 1, num,xxx;
	p[n].y = a; p[n].z = 0; ji[a] = 1;
	while (n<1070)
	{
		
		fa[1] = p[n].y / 1000;//方向一为千位数
		fa[2] = p[n].y / 100 % 10;//方向二位百位数
		fa[3] = p[n].y / 10 % 10;//方向三为十位数
		fa[4] = p[n].y % 10;//方向四为个位数
		for (int i = 1; i <= 4; i++)
		{
			xxx = fa[i];
			for (int j = 0; j < 10; j++)
			{
				if (xxx!= j)
				{
					fa[i] = j;
					num = fa[1] * 1000 + fa[2] * 100 + fa[3] * 10 + fa[4];
					if (num >= 1000 && num < 10000 && ji[num] == 0 && judge[num] == 0)
					{
						p[m].y = num;
						  p[m].z = p[n].z + 1;
						 ji[num] = 1;
						if (num == b) {
							t = 1; return p[m].z;
						}m++;
					}
				}fa[i] = xxx;//该方向搜完后要恢复该数字
			}
		}n++;
	}

}
int main()
{
	int a, b,c;
	cin >> c;
	while (c--)
	{
		cin >> a >> b;
		sushu(); 
		if (a == b)cout << 0 << endl;
		else {
		int ans = bfs(a, b);
		if (t)cout << ans << endl;
		else cout << "Impossible" << endl;
		}
	}

}