HDU1226:超级密码(BFS)

Problem Description

Ignatius花了一个星期的时间终于找到了传说中的宝藏,宝藏被放在一个房间里,房间的门用密码锁起来了,在门旁边的墙上有一些关于密码的提示信息:
密码是一个C进制的数,并且只能由给定的M个数字构成,同时密码是一个给定十进制整数N(0<=N<=5000)的正整数倍(如果存在多个满足条件的数,那么最小的那个就是密码),如果这样的密码存在,那么当你输入它以后门将打开,如果不存在这样的密码......那就把门炸了吧.

注意:由于宝藏的历史久远,当时的系统最多只能保存500位密码.因此如果得到的密码长度大于500也不能用来开启房门,这种情况也被认为密码不存在.

 

Input

输入数据的第一行是一个整数T(1<=T<=300),表示测试数据的数量.每组测试数据的第一行是两个整数N(0<=N<=5000)和C(2<=C<=16),其中N表示的是题目描述中的给定十进制整数,C是密码的进制数.测试数据的第二行是一个整数M(1<=M<=16),它表示构成密码的数字的数量,然后是M个数字用来表示构成密码的数字.两个测试数据之间会有一个空行隔开.

注意:在给出的M个数字中,如果存在超过10的数,我们约定用A来表示10,B来表示11,C来表示12,D来表示13,E来表示14,F来表示15.我保证输入数据都是合法的.

 

Output

对于每组测试数据,如果存在要求的密码,则输出该密码,如果密码不存在,则输出"give me the bomb please".

注意:构成密码的数字不一定全部都要用上;密码有可能非常长,不要试图用一个整型变量来保存密码;我保证密码最高位不为0(除非密码本身就是0).

 

Sample Input

  
  

   
   3
22 10
3
7 0 1

2 10
1
1

25 16
3
A B C
  
  

 

Sample Output

  
  

   
   110
give me the bomb please
CCB


   
   

    
    

     
     Hint
    
    
Hint
   
   
   
    
Huge input, scanf is recommended.
  
  

 

 

题意：给出n,c,m,密码必须是n这个十进制数的整数倍，c代表这个密码是C进制数，m代表这个密码只有m种字符构成，而且密码不能长于500

思路：一开始的第一想法是暴力，因为题目整整给了10S的时间，但是在第二个样例就卡住了，因为要让2的倍数一个个翻上去，要到长度为500也是需要大量的时间，很明显暴力是行不通的，然后苦想了一下午没有结果，晚上看别人的代码，没有注释，理解了老半天，终于理解了，主要就是将给出的字符一次次进行遍历，压入队列，直到满足要求或者超出长度则结束

 

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <algorithm>  
4. #include <queue>  
5. using namespace std;  
6.   
7. int num[20],vis[5005];  
8. int n,c,m;  
9.   
10. struct node  
11. {  
12.     int s[505];//将每一位的字符压入此数组  
13.     int len;  
14. };  
15.   
16. int print(node a)//输出函数  
17. {  
18.     int i;  
19.     for(i = 0; i<a.len; i++)  
20.     {  
21.         if(a.s[i]<=9)  
22.             printf("%d",a.s[i]);  
23.         else  
24.             printf("%c",a.s[i]+'A'-10);  
25.     }  
26.     printf("\n");  
27. }  
28.   
29. int mod(node a)//由于数字大，采用这种大数取模方式  
30. {  
31.     int i,tem = 0;  
32.     for(i = 0; i<a.len; i++)  
33.     {  
34.         tem = (tem*c+a.s[i])%n;//由于是n进制，tem在前面的基础上乘以进制数c在加上下一位，如果能整除n，那必定是n的倍数，则成立  
35.     }  
36.     return tem;  
37. }  
38.   
39. int BFS()  
40. {  
41.     memset(vis,0,sizeof(vis));  
42.     node a;  
43.     queue<node> Q;  
44.     a.len = 0;  
45.     int i,r;  
46.     for(i = 1; i<16; i++)//由于第一位不能为0，所以从1开始  
47.     {  
48.         if(num[i])//这个数是给出的样例  
49.         {  
50.             a.s[0] = i;//压入数组  
51.             a.len = 1;//长度变化  
52.             r = mod(a);  
53.             if(!r)//模为0，则肯定是n的倍数，输出  
54.             {  
55.                 print(a);  
56.                 return 1;  
57.             }  
58.             else  
59.             {  
60.                 if(!vis[r])//余数不能与之前出现过的余数相同，因为前面出现过的序列，肯定包含同样余数却在后面出现的序列  
61.                 {  
62.                     vis[r] = 1;//标记该余数已被访问  
63.                     Q.push(a);  
64.                 }  
65.             }  
66.         }  
67.     }  
68.     while(!Q.empty())  
69.     {  
70.         a = Q.front();  
71.         Q.pop();  
72.         for(i = 0; i<16; i++)  
73.         {  
74.             if(num[i])  
75.             {  
76.                 a.s[a.len] = i;  
77.                 a.len++;  
78.                 r = mod(a);  
79.                 if(!r)//一直找到能整除n的方案  
80.                 {  
81.                     print(a);  
82.                     return 1;  
83.                 }  
84.                 else  
85.                 {  
86.                     if(!vis[r] && a.len<499)  
87.                     {  
88.                         vis[r] = 1;  
89.                         Q.push(a);  
90.                     }  
91.                 }  
92.                 a.len--;//是不是觉得这里与a.len++这句话会无限重复，导致a.len一直为1？错了！要注意，在r与之前出现过的余数相同是，这次的a是没有压入队列的，也就是这次的a.len减少了，但是在队列中的a.len却没有减少！  
93.             }  
94.         }  
95.     }  
96.     return 0;  
97. }  
98.   
99. int main()  
100. {  
101.     int t,i;  
102.     char str[2];  
103.     scanf("%d",&t);  
104.     while(t--)  
105.     {  
106.         scanf("%d%d%d",&n,&c,&m);  
107.         memset(num,0,sizeof(num));  
108.         for(i = 0; i<m; i++)  
109.         {  
110.             scanf("%s",str);  
111.             if(str[0]>='0' && str[0]<='9')  
112.                 num[str[0]-'0'] = 1;  
113.             else  
114.                 num[str[0]-'A'+10] = 1;  
115.         }  
116.         if(n)  
117.         {  
118.             int flag;  
119.             flag = BFS();  
120.             if(!flag)  
121.                 printf("give me the bomb please\n");  
122.         }  
123.         else  
124.         {  
125.             if(num[0])  
126.                 printf("0\n");  
127.             else  
128.                 printf("give me the bomb please\n");  
129.         }  
130.     }  
131.     return 0;  
132. }