hduoj 1973 Prime Path bfs

hduoj 1973 Prime Path bfs

四位数的素数，改变其中一位变成另外一个素数，问最少需要多少次变换，才能将给定的一个素数变成另一个素数。

思路是利用bfs，将原始素数入队，枚举改变的数字，判断是否是素数，是的话入队，直到遇到目标素数，如果到队列为空也没有变换成目标素数，那么就是不能变换到，输出Impossible。

判断素数我写的是使用素数筛法，因为数据量小，也可以写一个函数来判断。

代码：

/*************************************************************************
    > File Name: 1973.cpp
    > Author: gwq
    > Mail: gwq5210@qq.com 
    > Created Time: 2015年05月02日 星期六 22时07分56秒
 ************************************************************************/

#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>

#define INF (INT_MAX / 10)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define pb push_back
#define sz(a) ((int)(a).size())

using namespace std;
typedef set<int> si;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef long long ll;

const double esp = 1e-5;

#define N 10010

int isnpri[N], vis[N];

struct Node {
    int x, s;
    Node(int a, int b)
    {
        x = a;
        s = b;
    }
};

int bfs(int from, int to)
{
    queue<Node> q;
    q.push(Node(from, 0));
    vis[from] = 1;
    while(!q.empty()) {
        Node u = q.front();
        q.pop();
        if (u.x == to) {
            return u.s;
        }
        for (int i = 1; i <= 9; i += 2) {
            int x = u.x / 10 * 10 + i;
            if (x != u.x && !vis[x] && !isnpri[x]) {
                vis[x] = 1;
                q.push(Node(x, u.s + 1));
            }
        }
        for (int i = 0; i <= 9; ++i) {
            int x = u.x / 100 * 100 + i * 10 + u.x % 10; 
            if (x != u.x && !vis[x] && !isnpri[x]) {
                vis[x] = 1;
                q.push(Node(x, u.s + 1));
            }
        }
        for (int i = 0; i <= 9; ++i) {
            int x = u.x / 1000 * 1000 + i * 100 + u.x % 100;
            if (x != u.x && !vis[x] && !isnpri[x]) {
                vis[x] = 1;
                q.push(Node(x, u.s + 1));
            }
        }
        for (int i = 1; i <= 9; ++i) {
            int x = i * 1000 + u.x % 1000;
            if (x != u.x && !vis[x] && !isnpri[x]) {
                vis[x] = 1;
                q.push(Node(x, u.s + 1));
            }
        }
    }
    return -1;
}

int main(int argc, char *argv[])
{
    memset(isnpri, 0, sizeof(isnpri));
    isnpri[0] = isnpri[1] = 1;
    for (int i = 2; i < N; ++i) {
        if (!isnpri[i]) {
            for (int j = i * i; j < N; j += i) {
                isnpri[j] = 1;
            }
        }
    }
    int t;
    scanf("%d", &t);
    while (t--) {
        int from, to;
        scanf("%d%d", &from, &to);
        memset(vis, 0, sizeof(vis));
        int flag = bfs(from, to);
        if (flag < 0) {
            printf("Impossible\n");
        } else {
            printf("%d\n", flag);
        }
    }
    return 0;
}