非常可乐

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7977    Accepted Submission(s): 3180

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
7 4 3
4 1 3
0 0 0
 
Sample Output
NO
3

题解：没有初始化，错了半天。。。。。。我真是无语了；直接队列定义在bfs里面就行了

代码1：

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

代码2：

  1.  #include<iostream>
  2.  #include<cstdio>
  3.  #include<cstring>
  4.  #include<cmath>
  5.  #include<algorithm>
  6.  #include<queue>
  7.  using namespace std;
  8.  const int INF=0x3f3f3f3f;
  9.  int c[];
  10.  int vis[][];
  11.  struct Node{
  12.      int v[],step;
  13.  };
  14.  bool check(Node a){
  15.      int x,y,z;
  16.      x=a.v[];y=a.v[];z=a.v[];
  17.      int t=c[]/;
  18.      //printf("%d %d %d %d\n",x,y,z,t);
  19.      if(x==t&&y==t)return true;
  20.      if(y==t&&z==t)return true;
  21.      if(x==t&&z==t)return true;
  22.      return false;
  23.  }
  24.  void bfs(){
  25.      Node a,b;
  26.      memset(vis,,sizeof(vis));
  27.      queue<Node>dl;
  28.      a.v[]=c[];
  29.      a.v[]=;
  30.      a.v[]=;
  31.      a.step=;
  32.      dl.push(a);
  33.      vis[a.v[]][a.v[]]=;
  34.      while(!dl.empty()){
  35.          a=dl.front();
  36.          dl.pop();
  37.          for(int i=;i<;i++)
  38.          for(int j=;j<;j++){
  39.              if(i==j)continue;
  40.              b=a;
  41.              b.step=a.step+;
  42.              if(b.v[i]>=c[j]-b.v[j]){
  43.                  b.v[i]=b.v[i]-(c[j]-b.v[j]);
  44.                  b.v[j]=c[j];
  45.              }
  46.              else{
  47.                  b.v[j]+=b.v[i];
  48.                  b.v[i]=;
  49.              }
  50.              if(check(b)){
  51.                      printf("%d\n",b.step);return;
  52.                  }
  53.                  if(!vis[b.v[]][b.v[]]){
  54.                      dl.push(b);vis[b.v[]][b.v[]]=;
  55.                  }
  56.          }
  57.          }
  58.      puts("NO");
  59.  }
  60.  int main(){
  61.      while(~scanf("%d%d%d",c,c+,c+),c[]|c[]|c[]){
  62.          if(c[]&)puts("NO");
  63.          else bfs();
  64.      }
  65.      return ;}

非常可乐（bfs）的更多相关文章

  1. HDU1459 非常可乐(BFS) 2016-07-24 15:00 165人阅读 评论(0) 收藏

    非常可乐 Problem Description 大家一定觉的运动以后喝可乐是一件很惬意的事情,但是seeyou却不这么认为.因为每次当seeyou买了可乐以后,阿牛就要求和seeyou一起分享这一瓶 ...

  2. HDU1495 非常可乐 —— BFS + 模拟

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1495 非常可乐 Time Limit: 2000/1000 MS (Java/Others)    M ...

  3. (step4.2.5)hdu 1495(非常可乐——BFS)

    题目大意:输入三个整数 a,b,c.   a : 可乐瓶的容量,b: 甲杯的容量 ,c: 乙杯的容量.问能否用这三个被来实现饮料的平分???如果可以输出倒饮料的次数, 否则输出NO 解题思路:BFS ...

  4. HDU 1495 非常可乐 BFS搜索

    题意:有个为三个杯子(杯子没有刻度),体积为s,n,m,s=m+n, 刚开始只有体积为s的杯子装满可乐,可以互相倒,问你最少的次数使可乐均分,如果没有结果,输出-1; 分析:直接互相倒就完了,BFS模 ...

  5. HDU 1495 非常可乐 BFS 搜索

    http://acm.hdu.edu.cn/showproblem.php?pid=1495 题目就不说了, 说说思路! 倒可乐 无非有6种情况: 1. S 向 M 倒 2. S 向 N 倒 3. N ...

  6. hdu_1495_非常可乐(bfs模拟)

    题目连接:http://acm.hdu.edu.cn/showproblem.php?pid=1495 题意:不解释 题解:BFS模拟,不过要细心,把所有情况都列举出来,开一个数组记录状态,代码有点长 ...

  7. HDU 1495 非常可乐 BFS

    题目大意:中文题不说了. 题目思路:我有同学用GCD数论写出来的代码很简洁,但是很抱歉,数论蒟蒻,我觉得比赛的时候我没办法推出.如果用BFS的话思路很简单的,就是6方向广搜,只不过稍微麻烦点.具体看代 ...

  8. HDU-1459.非常可乐(BFS )

    这道题TLE了很多次,原来一直以为将数字化为最简可以让运算更快,但是去了简化之后才发现,真正耗时的就是化简....还和队友学到了用状态少直接数组模拟刚就能过... 本题大意:给出可乐的体积v1,给出两 ...

  9. HDU - 1495 非常可乐 bfs互倒三杯水

    非常可乐 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submis ...

  10. HDU 1495 非常可乐 bfs 难度:1

    http://acm.hdu.edu.cn/showproblem.php?pid=1495 第三个杯子的盛水量可由前两个杯子得到,而前两个杯子状态总数在100*100以内,穷举可实现 #includ ...

随机推荐

  1. Linux学习之挂载

    linux的系统组织方式是——整个系统从根开始,按树形目录依次向下逐渐扩大,分类存放不同用途的文件,/读作“斜线”,英文slash:当其写作一个路径时,第一个/表示根,即root,其他的/表示路径分割 ...

  2. Windows上部署Redis

    http://www.cnblogs.com/gaobing/p/5026136.html

  3. Spring jdbcTemplate + EasyUI 物理分页

    前文说到,新项目中,用到的是SpringMVC + jdbcTemplate,前台是EasyUI,发现同事以前封装分页是逻辑分页,于是,自己动手封装了下物理分页. 这个是核心分页实体: import ...

  4. 本地环境下 WordPress 环境搭建与安装

    本地环境:Ubuntu 14.04 使用软件: WordPress 4.1.1 中文优化版 EasyEngine 安装步骤: 安装 LNMP 环境; wget -qO ee rt.cx/ee & ...

  5. 新浪sae 项目之 git 配置

    新浪sae 项目现在支持git 配置了,但是有好多人配置不成功.下面对这个问题进行一个总结. 1. 在新浪云上面新建项目(该步骤省略) 2. 一般新建完毕后,会让你选择代码的管理工具,如下 注意这里, ...

  6. 算法导论练习6.5-8 k路合并

    题目: 请给出一个时间为O(nlgk).用来将k个已排序链表合并为一个排序链表的算法.此处n为所有输入链表中元素的总数.(提示:用一个最小堆来做k路合并. 看到题目第个想到的是归并排序过程中的归并操作 ...

  7. github中的ssh配置

    1.配置git信息 设置git的user name和email: $ git config --global user.name "tigerjibo"$ git config - ...

  8. java设计模式（二）单例模式 建造者模式

    (三)单例模式 单例模式应该是最常见的设计模式,作用是保证在JVM中,该对象仅仅有一个实例存在. 长处:1.降低某些创建比較频繁的或者比較大型的对象的系统开销. 2.省去了new操作符,减少系统内存使 ...

  9. 搭建Myeclipse下Java Web开发环境

    1.准备 先下载软件:Myeclipse:http://www.xiazaiba.com/html/23858.html tomcat:http://files.cnblogs.com/files/l ...

  10. zoj 1081 (改进的弧长算法)（转）

    看到网上除了射线法,很长一段代码之外,看到了一个很简单的算法解决这个问题,特意转了过来 /* 这个算法是源自<计算机图形学基础教程>(孙家广,清华大学出版社),在该书 的48-49页,名字 ...