HDU 1495 非常可乐（广搜）

最新推荐文章于 2019-07-17 14:48:37 发布
最新推荐文章于 2019-07-17 14:48:37 发布
阅读量652 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xuejye/article/details/72973655
本文介绍了一个有趣的可乐分配问题，并通过广度优先搜索算法找到了解决该问题的方法。问题要求将一定量的可乐平均分配到两个不同容量的杯子中，文章详细展示了如何使用结构体存储每一步的状态，以及如何利用队列实现广度优先搜索算法来寻找最少的操作步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1495点击打开链接

非常可乐

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

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
 

Author
seeyou

广搜 同时注意标记 因为两个状态确定 第三个状态随之也确定 因此用二维数组就能储存 更加简便

代码有些冗长 分情况讨论 

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include<algorithm>
#include <math.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <queue>
#include <stack>
using namespace std;
struct xjy
{
    int i;
    int j;
    int k;
    int number;
};
int b[4];
int book[111][111];
int n;int m;int s;
int num=0;
void bfs()
{
    book[s][0]=1;
    int q,w,e;
    q=s;w=0;e=0;
    xjy mid;xjy midmid;
    mid.i=q;mid.j=w;mid.k=e;mid.number=0;
    queue <xjy> qu;
    qu.push(mid);
    while(!qu.empty())
        {
            mid=qu.front();
            qu.pop();
            if(((mid.i+mid.j)==s&&mid.i==mid.j)||((mid.i+mid.k)==s&&mid.i==mid.k)||((mid.k+mid.j)==s&&mid.k==mid.j))
            {
                
                num=mid.number;
                break;
            };
            
            if(mid.i>=(b[2]-mid.j))
            {
                midmid=mid;
                midmid.i=midmid.i-b[2]+midmid.j;
                midmid.j=b[2];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.i<(b[2]-mid.j))
            {
                midmid=mid;
                midmid.j+=midmid.i;
                midmid.i=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            
            if(mid.i>=(b[3]-mid.k))
            {
                midmid=mid;
                midmid.i=midmid.i-b[3]+midmid.k;
                midmid.k=b[3];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.i<(b[3]-mid.k))
            {
                midmid=mid;
                midmid.k+=midmid.i;
                midmid.i=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            
            if(mid.j>=(b[3]-mid.k))
            {
                midmid=mid;
                midmid.j=midmid.j-b[3]+midmid.k;
                midmid.k=b[3];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.j<(b[3]-mid.k))
            {
                midmid=mid;
                midmid.k+=midmid.j;
                midmid.j=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            
            if(mid.j>=(b[1]-mid.i))
            {
                midmid=mid;
                midmid.j=midmid.j-b[1]+midmid.i;
                midmid.i=b[1];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.j<(b[1]-mid.i))
            {
                midmid=mid;
                midmid.i+=midmid.j;
                midmid.j=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            
            if(mid.k>=(b[1]-mid.i))
            {
                midmid=mid;
                midmid.k=midmid.k-b[1]+midmid.i;
                midmid.i=b[1];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.k<(b[1]-mid.i))
            {
                midmid=mid;
                midmid.i+=midmid.k;
                midmid.k=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            
            if(mid.k>=(b[2]-mid.j))
            {
                midmid=mid;
                midmid.k=midmid.k-b[2]+midmid.j;
                midmid.j=b[2];
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
            if(mid.k<(b[2]-mid.j))
            {
                midmid=mid;
                midmid.j+=midmid.k;
                midmid.k=0;
                midmid.number++;
                if(book[midmid.i][midmid.j]!=1)
                {
                    qu.push(midmid);
                    book[midmid.i][midmid.j]=1;
                }
            }
        }
    }

int main()
{
    
    while(scanf("%d%d%d",&s,&n,&m)&&s&&n&&m)
    {
        if(n<m)
        {
            int t=n;
            n=m;
            m=t;
        }
        num=0;
        b[1]=s;
        b[2]=n;
        b[3]=m;
        for(int i=0;i<111;i++)
            for(int j=0;j<111;j++)
                    book[i][j]=0;
        bfs();
        if(num)
            printf("%d\n",num);
        else
            printf("NO\n");
    }
}

这次比赛又碰到了 附一下这次的吧 代码差不多

#include <iostream>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <limits.h>
#include <string>
#include <string.h>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
using namespace std;
char mmap[11][11];
int book[111][111][111];
struct xjy
{
    int nv;
    int mv;
    int kv;
};
int ans=INT_MAX;
xjy b,e;
int n,m,k;
int num;
int cnt;
queue <xjy > q;
int dir[4][2]={1,0,-1,0,0,1,0,-1};
void bfs()
{
    while(!q.empty())
        q.pop();
    xjy mid;
    mid.nv=n;
    mid.mv=0;
    mid.kv=0;
    q.push(mid);
    while(!q.empty())
    {
        mid=q.front();
        q.pop();
        if(((mid.nv==mid.mv)&&mid.nv==n/2)||((mid.kv==mid.mv)&&mid.mv==n/2)||((mid.nv==mid.kv)&&mid.nv==n/2))
           {
               ans=book[mid.nv][mid.mv][mid.kv];
               break;
           }
//cout << mid.nv<<" "<< mid.mv << " "<< mid.kv << endl;
        xjy midmid;
        midmid=mid;
        if(midmid.nv!=0||midmid.mv!=m)
        {
            if(midmid.nv>(m-midmid.mv))
            {
                midmid.nv-=(m-midmid.mv);
                midmid.mv=m;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.mv+=midmid.nv;
                midmid.nv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

        midmid=mid;
        if(midmid.nv!=0||midmid.kv!=k)
        {
            if(midmid.nv>(k-midmid.kv))
            {
                midmid.nv-=(k-midmid.kv);
                midmid.kv=k;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.kv+=midmid.nv;
                midmid.nv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

        midmid=mid;
        if(midmid.mv!=0||midmid.kv!=k)
        {
            if(midmid.mv>(k-midmid.kv))
            {
                midmid.mv-=(k-midmid.kv);
                midmid.kv=k;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.kv+=midmid.mv;
                midmid.mv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

        midmid=mid;
        if(midmid.mv!=0||midmid.nv!=n)
        {
            if(midmid.mv>(n-midmid.nv))
            {
                midmid.mv-=(n-midmid.nv);
                midmid.nv=n;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.nv+=midmid.mv;
                midmid.mv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

        midmid=mid;
        if(midmid.kv!=0||midmid.mv!=m)
        {
            if(midmid.kv>(m-midmid.mv))
            {
                midmid.kv-=(m-midmid.mv);
                midmid.mv=m;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.mv+=midmid.kv;
                midmid.kv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

        midmid=mid;
        if(midmid.kv!=0||midmid.nv!=n)
        {
            if(midmid.kv>(n-midmid.nv))
            {
                midmid.kv-=(n-midmid.nv);
                midmid.nv=n;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
            else
            {
                midmid.nv+=midmid.kv;
                midmid.kv=0;
                if(!book[midmid.nv][midmid.mv][midmid.kv])
                {
                    q.push(midmid);
                    book[midmid.nv][midmid.mv][midmid.kv]=book[mid.nv][mid.mv][mid.kv]+1;
                }
            }
        }

    }
}

int main()
{

    while(~scanf("%d%d%d",&n,&m,&k)&&(n||m||k))
    {
        memset(book,0,sizeof(book));
        ans=INT_MAX;
        book[n][0][0]=1;
        if(n&1)
        {
            printf("NO\n");
            continue;
        }
        else
        {

        bfs();
        if(ans!=INT_MAX)
            printf("%d\n",ans-1);
        else
            printf("NO\n");
        }
    }
}

 


hdu 1495 非常可乐 BFS
Mr.CJ
04-03 1116
非常可乐 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1759 Accepted Submission(s): 743 Problem Description 大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却
hdu 1495 非常可乐 广搜
weixin_30894583的博客
07-05 92
#include<iostream> #include<cstdio> #include<cstring> #include<queue> int vi[102][102][102]; using namespace std; struct Point{ int a,b,c,v; Point(int x,int y...
hdu1495 非常可乐 (广搜)
苏苏爱自由
04-17 2153
非常可乐 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 14064    Accepted Submission(s): 5600 Problem Description 大家一定觉的运动以后喝可乐是一件很惬意的
hdu 1495 非常可乐（广搜）
booyoungxu的专栏
07-26 359
题目地址 题目大意：给出三个数s，n，m，（s=m+n）初始态为s装满可乐，n和m为空，求是否能将可能均分，若能输出倒可乐的最小次数 解题思路：对于3个杯中每个杯子有可乐时用队列将状态加入队尾，且标记当前状态，直到队列中有均分的情况停止 #include #include #include #include #include #include #include #include
hdu1495非常可乐【广搜】
MissZhou要努力
12-11 488
天国语言不解释，之前真没想到这种题居然还可以用广搜做，看这题想起来之前有一个学弟问我的木棍拼正方形的广搜了 提交之前各种白痴错误，if条件写错地方，条件写错，最开始vis[cur.s][cur.n][cur.m]=1写成next输出一堆中间变量才发现 不过还好是1A的，虽说我的代码又臭又长，实在想不出来来回倒可乐的方法除了判断当前情况是否能够满足s->m m->s s->n n->s m->n
hdu 1495 非常可乐 （广搜）
weixin_30507269的博客
09-29 99
题目链接 Problem Description 大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，阿牛就要求和seeyou一起分享这一瓶可乐，而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子，它们的容量分别是N 毫升和M 毫升 可乐的体积为S （S<101）毫升　(正好装满一瓶) ，它们三个之间可以相互倒可乐...
【HDU 1495】非常可乐 BFS
天才小熊猫的博客
03-05 313
非常可乐 Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 28016Accepted Submission(s): 10870 Problem Description 大家一定觉的运动以后喝可乐是一件很惬意的事情，但是s...
HDU 1495 非常可乐(广搜BFS) （M）
qq_36782366的博客
07-06 404
题意：相当于泊松分酒问题的简化版 三个杯子  容量为a，b，c  且a==b+c，一开始的时候a装满，求最少步数均分，如果不能输出NO 思路：广搜  每次都搜索6个操作 就是他们互相倒来倒去  用vis数组来判断这个状态是否已经出现过了进行剪枝 #include #include #include #include #include #include using namespace std;
搜索 BFS 非常可乐 HDU - 1495
laaahu的博客
07-17 655
搜索 BFS 非常可乐 HDU - 1495 **题目链接：**https://vjudge.net/problem/HDU-1495 题意： 现在有一杯可乐和两个杯子，是否可以把这一杯可乐分成体积完全相等的两份。 你可以将三个杯子中的可乐任意倒到其余两个杯子中但是操作结束之后你要知道每个杯子到底还有多少可乐，所以怎么倒很关键，你能随便倒这样你就不知道你是否将他成功分开了。 如果可以输出最...
HDU 1495 非常可乐(广搜)
Learn as if you were to live forever
04-14 840
原帖链接：http://blog.youkuaiyun.com/ilovexiaohao/article/details/8564830 可乐体积为S，互相之间来回倾倒饮料，判断是否可以将S平分。广搜所有的状态即可。 这份代码的优越在于二层for循环的使用，有效避免的冗长重复的代码。 #include #include #include #include using namespace std;
算法-非常可乐（HDU-1495）（包含源程序）.rar
09-16
标题中的“算法-非常可乐（HDU-1495）”是一个编程竞赛题目，通常在编程竞赛网站如HDU（杭州电子科技大学在线评测系统）上出现。这类题目旨在测试参赛者的算法设计和实现能力。这个题目可能涉及到的是一个特定的算法...
qduoj 这题别看了，跳过吧（深搜）
xuejye的博客
06-06 740
题目链接：https://qduoj.com/problem/150/点击打开链接 这题别看了，跳过吧 发布时间: 2017年6月3日 18:46   最后更新: 2017年6月3日 18:47   时间限制: 1000ms   内存限制: 128M 描述 有n个正整数，求从这n个正整数里选任意个数之后加和大于S有多少种选法 输入 第一行
ZOJ - 1085 Alien Security （bfs+dfs）
xuejye的博客
08-09 509
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1085点击打开链接 Alien Security Time Limit: 2 Seconds      Memory Limit: 65536 KB You are in charge of security at a top-secr
qduoj ycb惹女朋友生气了（广搜）
xuejye的博客
06-06 457
题目链接：https://qduoj.com/problem/152/点击打开链接 ycb惹女朋友生气了 发布时间: 2017年6月3日 18:46   最后更新: 2017年6月3日 18:49   时间限制: 1000ms   内存限制: 128M 描述           话说上题中,ycb刚在博知楼饮水机排完队打水,女朋友来电话说也想喝水,让ycb去接水
CodeForces - 377A Maze （广搜+记忆化）
xuejye的博客
07-27 401
http://codeforces.com/problemset/problem/377/A点击打开链接 A. Maze time limit per test 2 seconds memory limit per test 256 megabytes input standard input output
FZU - 2150 Fire Game（暴力+广搜）
xuejye的博客
07-29 401
题目链接：http://acm.fzu.edu.cn/problem.php?pid=2150点击打开链接 Problem 2150 Fire Game Accept: 2540    Submit: 8781 Time Limit: 1000 mSec    Memory Limit : 32768 KB  Problem Description Fat bro
HDU ACM教程：搜索技术入门指南
### HDU ACM 教案知识点 - 搜索入门 #### 标题解析 标题“hdu acm 教案(7)”指的是在哈尔滨工业大学（Harbin Institute of Technology, 简称：HIT）所使用的ACM训练教案的第七份材料，主要关注搜索算法入门。 ###...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值