1.19--题H（bfs）

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

题解：参考了一下别人的思路，比如第一组数据1033，先把这四位数拆开每一位数用数组存起来，把每一位数字都从0-9变化（除左边第一位，左边第一位是从1-9），判断是否是素数，是，就放入队列里面，然后队列里面的数重复循环以上操作。

以下是AC代码：

#include<iostream>
#include<queue>
using namespace std;
int a[10000] = { 0 };               //数组a用来标记素数
int main()
{
	int n;
	cin >> n;
	for (int i = 1000; i < 10000; i++)          //查找四位数的素数
		for (int j = 2; j < i; j++)
			if (i%j == 0)
				break;
			else if (j == i - 1)
				a[i] = 1;                            //标记为1的就是素数，这样就可以给下面进行素数判断了
	while (n--)
	{
		queue<int> dl;
		int p, q, t[4], ot[4], z, c[10000] = { 0 }, visit[10000] = { 0 };
		cin >> p >> q;
		if (p == q)
			goto A;
		dl.push(p);
		while (dl.size()!=0)
		{
			ot[3] = t[3] =dl.front() % 10, ot[2] = t[2] = dl.front() / 10 % 10, ot[1] = t[1] = dl.front() / 100 % 10, ot[0] = t[0] = dl.front() / 1000 % 10;            //把四位数逐个拆开
			for (int i = 0; i < 4; i++)
			{
				if (i == 0)                  //i=0表示左边第一位数，如果是左边第一位数，就从1开始逐渐增加
					t[i] = 1;
				else t[i] = 0;               //若不是左边第一位，就从0开始增加
				while (t[i] <= 9)
				{
					if (t[i] == ot[i])                 //排除在变化过程中，与变化前的数重复了，比如1033，从左边第一位开始增加，还是1033，所以要增加到2033，防止重复了
					{
						t[i]++; continue;
					}
					z = t[0] * 1000 + t[1] * 100 + t[2] * 10 + t[3];            //z把拆开的四个数重新组合成一个四位数
					if (a[z] == 1&&!visit[z])               //若z是素数且没有被标记过（即visit[z]不为1，也就是说没有被放入队列中），注意：一定要有标记是否被放入队列，因为后面变化过程中有重复同一个数字的
					{
						c[z] = c[dl.front()] + 1;            //c数组用来标记层数的，比如1063和1039都从1033变过来，那么1063和1039都是变化后的第一层（目的在于最后可以直接输出c[q]表示最终结果）
						dl.push(z),visit[z]=1;             //放入队列中并作标记
						if (z == q)
							goto A;
					}
					t[i]++;
				}
				t[i] = ot[i];
			}
			dl.pop();
		}
	A:           cout << c[q] << endl;
	}
}