Mathematics:Prime Path(POJ 3126)

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　  素数通道

　　题目大意：给定两个素数a,b，要你找到一种变换，使得每次变换都是素数，如果能从a变换到b，则输出最小步数，否则输出Impossible

　　水题，因为要求最小步数，所以我们只需要找到到每个素数的最小步数就可以了，每个权都是1，所以用BFS就可以了，一开始我还用DFS，太丢人了，一开始就把素数表打好就可以了

　　

#include <iostream>
#include <functional>
#include <algorithm>

using namespace std;

typedef int Position;
typedef struct _set
{
    char num[4];
}Set,Queue;
bool BFS(const int);
void Search_Prime(void);
int Get_Num(char *);

static bool prime_set[10000];
static char num[4], goal_set[4];
static int min_step[10000], pow_sum[4] = { 1, 10, 100, 1000 };
static void Push(char *,Position);
static char *Pop(Position);
Queue que[2 * 10000];

int main(void)
{
    int case_sum, goal_num;

    Search_Prime();
    scanf("%d", &case_sum);

    while (case_sum--)
    {
        getchar();
        scanf("%c%c%c%c", &num[0], &num[1], &num[2], &num[3]);
        getchar();
        scanf("%c%c%c%c", &goal_set[0], &goal_set[1], &goal_set[2], &goal_set[3]);
        goal_num = Get_Num(goal_set);
        if (!BFS(goal_num))
            printf("Impossible
");
    }

    return 0;
}

int Get_Num(char *s)
{
    int ans = 0;
    for (int i = 0; i < 4; i++)
        ans += (s[3 - i] - '0') * pow_sum[i];
    return ans;
}

void Search_Prime(void)//线筛法打表
{
    int i, j;
    prime_set[1] = 1;
    memset(prime_set, 0, sizeof(prime_set));
    for (i = 2; i < 10000; i++)
    {
        for (j = 2; j <= i && i*j < 10000; j++)
            if (!prime_set[j])
                prime_set[i*j] = 1;
    }
}

static void Push(char *num, Position back)
{
    for (int i = 0; i < 4; i++)
        que[back].num[i] = num[i];
}

static char *Pop(Position head)
{
    return que[head].num;
}

bool BFS(const int goal)
{
    memset(min_step, -1, sizeof(min_step));
    Position head = 0, back = 0;
    int i, j, sum_tmp, step_now;
    char *out, tmp_int;

    sum_tmp = Get_Num(num);
    if (sum_tmp == goal)
    {
        printf("0
");
        return true;
    }
    Push(num, back++); min_step[sum_tmp] = 0;

    while (head != back)
    {
        out = Pop(head++); sum_tmp = Get_Num(out);
        step_now = min_step[sum_tmp];
        for (i = 0; i < 4; i++)
        {
            tmp_int = out[i];
            for (j = 0; j < 10; j++)
            {
                if (i == 0 && j == 0 || tmp_int == j + '0') continue;
                out[i] = j + '0';
                sum_tmp = Get_Num(out);
                if (min_step[sum_tmp] == -1 && !prime_set[sum_tmp])
                {
                    min_step[sum_tmp] = step_now + 1;
                    Push(out, back++);
                    if (sum_tmp == goal)
                    {
                        printf("%d
", min_step[sum_tmp]);
                        return true;
                    }
                }
            }
            out[i] = tmp_int;
        }
    }
    return false;
}