题意

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是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
  1. ---------------------------------------------------------我是分割线----------------------------------------------------------------------------------------------------------------------
  1. 某童靴的一般思路  (感谢@陌类  提供的代码)

　　(较麻烦的题解, 好像多数人都这么写~

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

　

　简单点评

　　在上面的代码, 每次for循环都将枚举六种情况 ,1->2 , 1-》3,2-》3 ，2-》1,3-》1,3-》2  ，并且每种情况又要分为两种来讨论......

　　 重复的部分太多了~

　　重复的部分太多了~

　　不够简洁，代码太长长了。

　　出错误了一不好找啊!

-------------------------------------------------------------------------------------------------------------------------------------我是分割线---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

　　起先我也是这么做的，后来我想了一个相对简单的优化办法：

　　进行结构体的嵌套 ,结构体cup 的 a[1]/a[2]/a[3]分别代表这 三个容器 ,其中结构体 cup中 up 代表一个容器的装水上限 ,now  代表现在的水量! 再用 结构体node 将cup和step 封装起来!

  1.  #include<iostream>
  2.  #include<algorithm>
  3.  #include<cstdio>
  4.  #include<cstring>     //by  @山枫叶纷飞
  5.  #include<cstdlib>
  6.  #include<cmath>
  7.  #include<string>
  8.  #include<set>
  9.  #include<queue>
  10.  using namespace std;
  11.  typedef long long ll;
  12.  double dinf=99999999.9, mm=1e-;
  13.  const int N=,inf=0x3f3f3f3f;
  14.  int s,n,m;
  15.  int vis[N][N][N];
  16.  struct cup
  17.  {
  18.      int up,now;
  19.  };
  20.  struct node
  21.  {
  22.       cup a[];  ///进行结构体的嵌套 ,a[1]/a[2]/a[3] 分别表示三个容器
  23.      int step;
  24.  };
  25.  int bfs( )
  26.  {
  27.      int i,j,k;
  28.      queue<node>Q;
  29.      node p,q;
  30.      p.a[].now=s;p.a[].up=s;
  31.      p.a[].now=;p.a[].up=n;
  32.      p.a[].now=;p.a[].up=m;
  33.      p.step=;
  34.      memset(vis,,sizeof(vis));vis[s][][]=;
  35.      Q.push(p);
  36.      while(Q.size()>)
  37.      {
  38.          p=Q.front(); ///从队列中取到的现在的状态
  39.          Q.pop();
  40.          if((p.a[].now==s/&&p.a[].now==s/) || (p.a[].now==s/&&p.a[].now==s/))///判断是否达到预期结果
  41.              return p.step;
  42.          if((p.a[].now==s/&&p.a[].now==s/))///判断是否达到预期结果(太长了,拆成了两段)
  43.              return p.step;
  44.  
  45.          for(i=;i<=;i++)
  46.          {
  47.              for(j=;j<=;j++)
  48.              {
  49.                  if(i==j || p.a[i].now==||p.a[j].now==p.a[j].up)///简易排除
  50.                      continue;
  51.  
  52.                  q=p;///初始化,q 代表由p 延伸来的下一状态
  53.  
  54.                 int dif=p.a[j].up-p.a[j].now;///表示容器a[j]最多可添加水量
  55.                  if(p.a[i].now>=dif)///若容器a[j]可被填满水
  56.                  {
  57.                      q.a[i].now=p.a[i].now-dif;
  58.                      q.a[j].now=p.a[j].up;
  59.                  }
  60.                  else ///若容器a[j]不能装满水
  61.                  {
  62.                      q.a[i].now=;
  63.                      q.a[j].now=p.a[i].now+p.a[j].now;
  64.                  }
  65.                  q.step=p.step+;
  66.                  if(vis[q.a[].now][q.a[].now][q.a[].now]==)
  67.                  {
  68.                      vis[q.a[].now][q.a[].now][q.a[].now]=;
  69.                      Q.push(q);
  70.                  }
  71.              }
  72.          }
  73.  
  74.      }
  75.      return -;
  76.  }
  77.  int main()
  78.  {
  79.      while(scanf("%d%d%d",&s,&n,&m),s+n+m)
  80.      {
  81.          if(s%!=)///奇数一定无法均分成两份
  82.              printf("NO\n");
  83.          else
  84.          {
  85.              int k=bfs();
  86.              if(k==-)
  87.                  printf("NO\n");
  88.              else
  89.                  printf("%d\n",k);
  90.          }
  91.      }
  92.  
  93.      return ;
  94.  }

　简单点评

　　两重for 循环，用a[i] 和a[j] 来模拟全部六种情况的倒水过程 ,省了超过100行的代码, 结构体的含义一目了然,  就是结构体名字写起来太长了!

　　还有要注意的是: { q=p;///初始化,q 代表由p 延伸来的下一状态}这段代码的位置很重要, 每次新的内层for循环都要记得将q重新初始化, 不然会造成意料之外的错误! 当时debug 到了 "debug人在天涯"!

  1. ---------------------------------------------------------我是分割线----------------------------------------------------------------------------------------------------------------------
    其他思路
    　　这个题目用数论也是可以做的! 近似玄学，，，感兴趣的话自行百度！

HDU-1495 非常可乐 (嵌套结构体-广搜 对比 一般广搜)的更多相关文章

  1. HDU 1495 非常可乐 （只是转了个弯的广搜题）

    N - 非常可乐 =========================================================================================== ...

  2. abap中结构体嵌套结构体。

    1: 结构体中嵌套结构体. *&---------------------------------------------------------------------* *& Re ...

  3. C语言 结构体（嵌套结构体--结构体数组）

    //结构体--嵌套结构体和结构体数组 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> ...

  4. BFS(倒水问题) HDU 1495 非常可乐

    题目传送门 /* BFS:倒水问题,当C是奇数时无解.一共有六种情况,只要条件符合就入队,我在当该状态vised时写了continue 结果找了半天才发现bug,泪流满面....(网上找份好看的题解都 ...

  5. matlab学习笔记12_2创建结构体数组,访问标量结构体,访问非标量结构体数组的属性,访问嵌套结构体中的数据，访问非标量结构体数组中多个元素的字段

    一起来学matlab-matlab学习笔记12 12_2 结构体 创建结构体数组,访问标量结构体,访问非标量结构体数组的属性,访问嵌套结构体中的数据,访问非标量结构体数组中多个元素的字段 觉得有用的话 ...

  6. go变量、类的概念以及类的使用方式，嵌套结构体

    go变量.类的概念以及类的使用方式,嵌套结构体 Go变量 go使用var声明变量,当声明变量时,这个变量对应的值总是会被初始化.这个值要么用指定的值初始化,要么用零值(即变 量类型的默认值)做初始化. ...

  7. hdu 1495 非常可乐 （广搜）

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

  8. hdu 1495 非常可乐 广搜

    #include<iostream> #include<cstdio> #include<cstring> #include<queue> ][][]; ...

  9. HDU 1495 非常可乐(数论，BFS)

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

随机推荐

  1. Spring 3整合Quartz 2实现手动设置定时任务：新增，修改，删除，暂停和恢复（附带源码）

    摘要:在项目的管理功能中,对定时任务的管理有时会很常见.但一般定时任务配置都在xml中完成,包括cronExpression表达式,十分的方便.但是如果我的任务信息是保存在数据库的,想要动态的初始化, ...

  2. 正则表达式去除字符串左右空格函数 调用方法是，str.Trim();

    正则表达式去除字符串左右空格函数 调用方法是,str.Trim(); String.prototype.Trim = function() { return this.replace(/(^\s*)| ...

  3. Ubuntu下使用nginx和nginx-rtmp-module搭建流媒体服务器的正确姿势

    之前在使用nginx和nginx-rtmp-module搭建流媒体服务器的时候遇到一个很尴尬的问题,就是在把nginx-rtmp-module模块添加到nginx中去的时候,我最开始采取的做法是先卸载 ...

  4. undefined variable _session php

    解决方法: if (version_compare(PHP_VERSION, '5.4.0', '<')) { if(session_id() == '') {session_start();} ...

  5. smarty模板基础知识

    1.定义 Smarty是一个使用php写出来的模板引擎,它分离了逻辑代码和外在的内容,提供了一种易于管理和使用的方法,用来将原本与html代码混杂在一起PHP代码逻辑分离. 简单的讲,目的就是要使PH ...

  6. MATLAB命令大全和矩阵操作大全

    转载自: http://blog.csdn.net/dengjianqiang2011/article/details/8753807 MATLAB矩阵操作大全 一.矩阵的表示在MATLAB中创建矩阵 ...

  7. work1-英语辅导班在线报名系统

    作品简述: 这是一个英语辅导班在线报名系统,目的是提供一个供学生报名辅导班的平台,也同时为老师收集报名信息提供便利. 使用的语言: php+html+js 服务器: 新浪sae服务器,apache 数 ...

  8. Error detected while processing function CheckFoam256 问题的解决

    今天在打开OpenFOAM的constant文件的时候, vim-OpenFOAM-syntax插件遇到了如下问题: Error detected while processing function ...

  9. PHP xmapp 下面安装 Composer-Setup.exe

    1.打开PHP配置文件E:\xampp\php\php.ini确认以下模块已开启(移除前面的分号). extension=php_openssl.dll, (php.ini文档里面开启一次就OK了) ...

  10. Angular基础（一）

    AngularJS有五个主要核心特性,如下介绍: 双向数据绑定 -- 实现了把model与view完全绑定在一起,model变化,view也变化,反之亦然. 模板 -- 在AngularJS中,模板相 ...