杭电-1495非常可乐(BFS)

爱被打了一巴掌 2022-08-09 17:43 229阅读 0赞

非常可乐

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 7999 Accepted Submission(s): 3198

Problem Description

大家一定觉的运动以后喝可乐是一件很惬意的事情,但是seeyou却不这么认为。因为每次当seeyou买了可乐以后,阿牛就要求和seeyou一起分享这一瓶可乐,而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子,它们的容量分别是N 毫升和M 毫升 可乐的体积为S (S<101)毫升 (正好装满一瓶) ,它们三个之间可以相互倒可乐 (都是没有刻度的,且 S==N+M,101>S>0,N>0,M>0) 。聪明的ACMER你们说他们能平分吗?如果能请输出倒可乐的最少的次数,如果不能输出”NO”。

Input

三个整数 : S 可乐的体积 , N 和 M是两个杯子的容量,以”0 0 0”结束。

Output

如果能平分的话请输出最少要倒的次数,否则输出”NO”。

Sample Input

  1. 7 4 3
  2. 4 1 3
  3. 0 0 0

Sample Output

  1. NO
  2. 3

这是一个隐藏的BFS,我们必须把每种情况都试一下,这样求出的一定是最少的步骤

我们分为以下几个步骤:

  1. 瓶子里还有可乐

(1)瓶子里的可乐能装满杯子 1

(2)瓶子里的可乐不能装满杯子 1

(3)瓶子里的可乐能装满杯子 2

(4)瓶子里的可乐不能装满杯子 2

2 .杯子1还有可乐

(1)杯子1里的可乐能装满瓶子

(2)杯子1里的可乐不能装满瓶子

(3)杯子1里的可乐能装满杯子 2

(4)杯子1里的可乐不能装满杯子 2

2 .杯子2还有可乐

(1)杯子2里的可乐能装满瓶子

(2)杯子2里的可乐不能装满瓶子

(3)杯子2里的可乐能装满杯子 1

(4)杯子2里的可乐不能装满杯子 1

这样来进行搜索就行了,我们用三维数组来标记三种杯子的情况

代码:

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<queue>
  5. using namespace std;
  6. int vis[101][102][102];
  7. int s,m,n;
  8. struct node{
  9. int a,b,c,step;
  10. }ta,tb;
  11. queue<node>Q;
  12. bool judge(node w)
  13. {
  14. int p=0;
  15. if(w.a==s/2)
  16. p++;
  17. if(w.b==s/2)
  18. p++;
  19. if(w.c==s/2)
  20. p++;
  21. if(p==2)
  22. return true;
  23. return false;
  24. }
  25. int bfs()
  26. {
  27. while(!Q.empty())
  28. Q.pop();
  29. ta.a=s;
  30. ta.b=0;
  31. ta.c=0;
  32. ta.step=0;
  33. Q.push(ta);
  34. memset(vis,0,sizeof(vis));
  35. vis[s][0][0]=1;
  36. while(!Q.empty())
  37. {
  38. ta=Q.front();
  39. Q.pop();
  40. if(judge(ta))
  41. return ta.step;
  42. if(ta.a)
  43. {
  44. if(ta.a>=m-ta.b)
  45. {
  46. tb=ta;
  47. tb.a=ta.a-(m-ta.b);
  48. tb.b=m;
  49. if(!vis[tb.a][tb.b][tb.c])
  50. {
  51. tb.step=ta.step+1;
  52. Q.push(tb);
  53. vis[tb.a][tb.b][tb.c]=1;
  54. }
  55. }
  56. else
  57. {
  58. tb=ta;
  59. tb.a=0;
  60. tb.b=ta.b+ta.a;
  61. if(!vis[tb.a][tb.b][tb.c])
  62. {
  63. tb.step=ta.step+1;
  64. Q.push(tb);
  65. vis[tb.a][tb.b][tb.c]=1;
  66. }
  67. }
  68. if(ta.a>=n-ta.c)
  69. {
  70. tb=ta;
  71. tb.a=ta.a-(n-ta.c);
  72. tb.c=n;
  73. if(!vis[tb.a][tb.b][tb.c])
  74. {
  75. tb.step=ta.step+1;
  76. Q.push(tb);
  77. vis[tb.a][tb.b][tb.c]=1;
  78. }
  79. }
  80. else
  81. {
  82. tb=ta;
  83. tb.a=0;
  84. tb.c=ta.a+ta.c;
  85. if(!vis[tb.a][tb.b][tb.c])
  86. {
  87. tb.step=ta.step+1;
  88. Q.push(tb);
  89. vis[tb.a][tb.b][tb.c]=1;
  90. }
  91. }
  92. }
  93. if(ta.b)
  94. {
  95. if(ta.b>=s-ta.a)
  96. {
  97. tb=ta;
  98. tb.b=ta.b-(s-ta.a);
  99. tb.a=s;
  100. if(!vis[tb.a][tb.b][tb.c])
  101. {
  102. tb.step=ta.step+1;
  103. Q.push(tb);
  104. vis[tb.a][tb.b][tb.c]=1;
  105. }
  106. }
  107. else
  108. {
  109. tb=ta;
  110. tb.b=0;
  111. tb.a=ta.b+ta.a;
  112. if(!vis[tb.a][tb.b][tb.c])
  113. {
  114. tb.step=ta.step+1;
  115. Q.push(tb);
  116. vis[tb.a][tb.b][tb.c]=1;
  117. }
  118. }
  119. if(ta.b>=n-ta.c)
  120. {
  121. tb=ta;
  122. tb.b=ta.b-(n-ta.c);
  123. tb.c=n;
  124. if(!vis[tb.a][tb.b][tb.c])
  125. {
  126. tb.step=ta.step+1;
  127. Q.push(tb);
  128. vis[tb.a][tb.b][tb.c]=1;
  129. }
  130. }
  131. else
  132. {
  133. tb=ta;
  134. tb.b=0;
  135. tb.c=ta.b+ta.c;
  136. if(!vis[tb.a][tb.b][tb.c])
  137. {
  138. tb.step=ta.step+1;
  139. Q.push(tb);
  140. vis[tb.a][tb.b][tb.c]=1;
  141. }
  142. }
  143. }
  144. if(ta.c)
  145. {
  146. if(ta.c>=s-ta.a)
  147. {
  148. tb=ta;
  149. tb.c=ta.c-(s-ta.a);
  150. tb.a=s;
  151. if(!vis[tb.a][tb.b][tb.c])
  152. {
  153. tb.step=ta.step+1;
  154. Q.push(tb);
  155. vis[tb.a][tb.b][tb.c]=1;
  156. }
  157. }
  158. else
  159. {
  160. tb=ta;
  161. tb.c=0;
  162. tb.a=ta.c+ta.a;
  163. if(!vis[tb.a][tb.b][tb.c])
  164. {
  165. tb.step=ta.step+1;
  166. Q.push(tb);
  167. vis[tb.a][tb.b][tb.c]=1;
  168. }
  169. }
  170. if(ta.c>=m-ta.b)
  171. {
  172. tb=ta;
  173. tb.c=ta.c-(m-ta.b);
  174. tb.b=m;
  175. if(!vis[tb.a][tb.b][tb.c])
  176. {
  177. tb.step=ta.step+1;
  178. Q.push(tb);
  179. vis[tb.a][tb.b][tb.c]=1;
  180. }
  181. }
  182. else
  183. {
  184. tb=ta;
  185. tb.c=0;
  186. tb.b=ta.b+ta.c;
  187. if(!vis[tb.a][tb.b][tb.c])
  188. {
  189. tb.step=ta.step+1;
  190. Q.push(tb);
  191. vis[tb.a][tb.b][tb.c]=1;
  192. }
  193. }
  194. }
  195. }
  196. return -1;
  197. }
  198. int main()
  199. {
  200. while(scanf("%d%d%d",&s,&m,&n),s+m+n)
  201. {
  202. if(s&1)
  203. {
  204. printf("NO\n");
  205. continue;
  206. }
  207. int t=bfs();
  208. if(t!=-1)
  209. printf("%d\n",t);
  210. else
  211. printf("NO\n");
  212. }
  213. return 0;
  214. }

发表评论

表情:
评论列表 (有 0 条评论,229人围观)

还没有评论,来说两句吧...

相关阅读

    相关 HDU 1253 胜利大逃亡(图 BFS

    本题难度并不大,一个普通的用BFS求解的题,值得注意的是数据的输入(三维数据输入被绕了几圈);还有就是最后的出口可以表示墙,无法出去(就是没考虑到这点WA了一次);剩下的就是B