POJ - 3126 Prime Path （BFS，未AC，代码求大神指教）

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
问题链接：http://poj.org/problem?id=3126
问题简述：输入两个素数，在个十百千位变化，每次变化只能变成另一个素数，求出由第一个素数变化到第二个素数所需要的最少步数
问题分析：我写了快一个小时DFS，就是求不出来…上网搜了一下发现好像只能用BFS（但是我还尚未掌握队列，暂时还没有想到不用队列写BFS的方法）…所以好像没有办法…我的代码我虽然知道为什么会跳不出循环无限DFS，但是没有想到一个办法能重置VISIT数组找出最少步数还能不无限循环。代码的详细注释在下方，求大神指教！。。。
未AC

#include<iostream>
#include <algorithm>
#include<iostream>
#include<string>
#include<stdio.h>
#include <algorithm>
#include<cstdlib>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn = 10005;
const int inf = 999999999;
bool vis[maxn];
int star, endn, ans = inf;//把答案设置成最大值
bool checkpri(int x)//判断素数
{
	for (int i = 2; i*i <= x; i++)
		if (x%i == 0)
			return 0;
	return 1;
}
bool checkright(int x)//判断条件，剪枝（排除偶数）
{
	if (checkpri(x) == 1 && vis[x] != 1 && x % 2 != 0) return 1;
	return 0;
}
void dfs(int star, int endn, int step)//起步，目标，步数计数
{
	vis[star] = 1;//起步标记访问过
	if (star == endn)
	{
		ans = min(ans, step);//如果找到了目标素数，记录最小步数
	}
	for (int i = 1; i < 10; i++)//千位
	{
		int t = i * 1000 + (star / 100) % 10 + (star / 10) % 10 + star % 10;
		if (checkright(t) == 1)
		{
			dfs(t, endn, step + 1);
			vis[t] = 0;//就是这里的标记归零使得无限循环，求大神们指教！
		}
	}
	for (int i = 0; i < 10; i++)//百位
	{
		int t = i * 100 + star / 1000 + (star / 10) % 10 + star % 10;
		if (checkright(t) == 1)
		{
			dfs(t, endn, step + 1);
			vis[t] = 0;//就是这里的标记归零使得无限循环，求大神们指教！
		}
	}
	for (int i = 0; i < 10; i++)//十位
	{
		int t = i * 10 + star / 1000 + (star / 100) % 10 + star % 10;
		if (checkright(t) == 1)
		{
			dfs(t, endn, step + 1);
			vis[t] = 0;//就是这里的标记归零使得无限循环，求大神们指教！
		}
	}
	for (int i = 0; i < 10; i++)//个位
	{
		int t = i + star / 1000 + (star / 100) % 10 + (star / 10) % 10;
		if (checkright(t) == 1)
		{
			dfs(t, endn, step + 1);
			vis[t] = 0;//就是这里的标记归零使得无限循环，求大神们指教！
		}
	}
	return;
}
int main()
{
	int n;
	cin >> n;
	while (n--)
	{
		memset(vis, 0, maxn);//重置访问数组
		ans = inf;//重置答案
		cin >> star >> endn;
		dfs(star, endn, 0);
		cout << ans << endl;//输出答案
	}
	return 0;
}