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[];
 }Set,Queue;
 bool BFS(const int);
 void Search_Prime(void);
 int Get_Num(char *);

 static bool prime_set[];
 static char num[], goal_set[];
 static int min_step[], pow_sum[] = { , , ,  };
 static void Push(char *,Position);
 static char *Pop(Position);
 Queue que[ * ];

 int main(void)
 {
     int case_sum, goal_num;

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

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

     return ;
 }

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

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

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

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

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

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

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