BFS（广度优先算法）—— pour water (A、B、C)

最新推荐文章于 2021-09-27 14:45:44 发布
最新推荐文章于 2021-09-27 14:45:44 发布
阅读量331 收藏
点赞数
分类专栏： c++ 文章标签： 算法 队列 bfs 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XianAnn/article/details/104597272
版权

题目描述：

倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。

数据输入：

输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。

Sample input：

				2 7 5
				2 7 4

数据输出：

你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单位的水。每组数据的最后一行输出应该是“success”。输出行从第1列开始，不应该有空行或任何尾随空格。
Sample output：

				fill B
				pour B A
				success 
				fill A
				pour A B
				fill A
				pour A B
				success

特别的：如果你的输出与Sample Output不同，那没关系。对于某个"A B C"本题的答案是多解的，不能通过标准的文本对比来判定你程序的正确与否。 所以本题由 SPJ（Special Judge）程序来判定你写的代码是否正确。

个人思路：

对于倒水问题，实在BFS 中一类特殊的存在——隐式图问题。它只给出了初始节点；目标节点以及扩展的条件等约束条件则隐含给出。
对于本题：初始节点是杯子为空：a = 0，b=0；目标是量出C单位的水，这里我认为目标节点是：a = C || b = C；下面最关键的BFS主体，考虑到题目限制对杯子的操作只有 fill or empty，两个杯子之间有 atob or btoa；所以对于两只杯子一共只有六种操作，而这六种操作就是BFS扩展的条件，操作后的新状态就是new node，然后判断是否push入队列就ok了。

数据结构：

struct cup {//杯子的状态
	int a, b, sign;//sign标记操作数{1，2，3，4，5，6}
	bool operator<(const cup& p)const {
		return a != p.a ? a < p.a : b < p.b;
	}
	bool operator == (const cup &q)const {
		return a == q.a || b == q.b;
	}
};
int A, B, C;//输入
cup s, t;//起终点
queue<cup> Q;//队列
map<cup, int> mp;//visit的作用
int mi = -1;//mp的指针
cup parent[100];//记录状态m的上一步操作parent[m]

在这里用的map来进行一个映射，首先是为了将cup类型转化为int型能够用于后面记录parent[mp[m]]，这里注意到mi是mp的指针，理论上来说mp么得指针，至于它的具体作用在后面给出具体介绍。map的另一个作用在BFS中给出。

BFS

此BFS用mp.count(key)替代了以往visit[ ]的作用，用来作为判断push入队列的条件。

void BFS() {
	s.a = s.b = 0;
	s.sign = 0;
	t.a = t.b = C;
	int i = mi;	//mp的指针

	mp.clear();//清空mp
	while (!Q.empty())//清空队列，因为多组数据可能会产生冲突
		Q.pop();

	Q.push(s);
	mp[s] = ++i;//指针后移
	cup final;
	while (!Q.empty()) {
		cup now = Q.front();
		Q.pop();

		if (now.a < A) {//fill A
			cup n = now;
			fillA(n);
			
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 1;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.b < B) {//fill B
			cup n = now;
			fillB(n);	
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 2;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.a != 0 && now.b != 0) {//empty A or B
			cup n1 = now;
			emptyA(n1);
			if (mp.count(n1) == 0) {//n1不在mp中
				n1.sign = 3;//sign记录n1是经过了什么操作
				//cout << n1.sign << endl;
				Q.push(n1);			
				mp[n1] = ++i;//指针后移
				parent[mp[n1]] = now;//n1的父节点是now，而mp[n1]则是其指针
			}
			if (n1 == t) {//判定是否到达终点
				final = n1;
				break;
			}
			cup n2 = now;
			emptyB(n2);
			if (mp.count(n2) == 0) {//n2不在mp中
				n2.sign = 4;//sign记录n2是经过了什么操作
				//cout << n2.sign << endl;
				Q.push(n2);
				mp[n2] = ++i;//指针后移
				parent[mp[n2]] = now;//n2的父节点是now，而mp[n2]则是其指针
			}
			if (n2 == t) {//判定是否到达终点
				final = n2;
				break;
			}
		}
		if (now.b != B && now.a != 0) {//pour A B
			cup n = now;
			AtoB(n);	
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 5;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);	
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.a != A && now.b != 0) {//pour B A
			cup n = now;
			BtoA(n);
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 6;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);			
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}			
	}
	fprint(final);//打印操作
	print(final);
	cout << "success" << endl;
	//cout << "( " << final.a << " , " << final.b << " )" << endl;
}

递归逆序输出到达终点的操作：

void print(const cup& n) {//根据sign标记输出操作
	if (n.sign == 1)
		cout << "fill A" << endl;
	else if (n.sign == 2)
		cout << "fill B" << endl;
	else if (n.sign == 3)
		cout << "empty A" << endl;
	else if (n.sign == 4)
		cout << "empty B" << endl;
	else if (n.sign == 5)
		cout << "pour A B" << endl;
	else if (n.sign == 6)
		cout << "pour B A" << endl;
	else
		return;

}

void fprint(cup& m) {//递归倒序输出操作
	if (m.a == s.a && m.b == s.b)return;//出口
	cup p = parent[mp[m]];
	
	fprint(p);
	print(p);
}

实现代码：

#include<iostream>
#include<queue>
#include<map>
using namespace std;

struct cup {//杯子的状态
	int a, b, sign;//sign标记操作数{1，2，3，4，5，6}
	bool operator<(const cup& p)const {
		return a != p.a ? a < p.a : b < p.b;
	}
	bool operator == (const cup& q)const {
		return a == q.a || b == q.b;
	}
};
int A, B, C;//输入
cup s, t;//起终点
queue<cup> Q;//队列
map<cup, int> mp;//visit的作用
int mi = -1;//mp的指针
cup parent[100];//记录状态m的上一步操作parent[m]

//六种操作
void fillA(cup& m) {
	m.a = A;
}
void fillB(cup& m) {
	m.b = B;
}

void emptyA(cup& m) {
	m.a = 0;
}
void emptyB(cup& m) {
	m.b = 0;
}
void AtoB(cup& m) {
	if (m.a >= B - m.b) {
		int t = m.b;
		m.b = B;
		m.a = m.a - (B - t);
	}
	else {
		m.b = m.b + m.a;
		m.a = 0;
	}
}
void BtoA(cup& m) {
	if (m.b >= A - m.a) {
		int t = m.a;
		m.a = A;
		m.b = m.b - (A - t);
	}
	else {
		m.a = m.b + m.a;
		m.b = 0;
	}
}

void print(const cup& n) {//根据sign标记输出操作
	if (n.sign == 1)
		cout << "fill A" << endl;
	else if (n.sign == 2)
		cout << "fill B" << endl;
	else if (n.sign == 3)
		cout << "empty A" << endl;
	else if (n.sign == 4)
		cout << "empty B" << endl;
	else if (n.sign == 5)
		cout << "pour A B" << endl;
	else if (n.sign == 6)
		cout << "pour B A" << endl;
	else
		return;

}

void fprint(cup& m) {//递归倒序输出操作
	if (m.a == s.a && m.b == s.b)return;//出口
	cup p = parent[mp[m]];

	fprint(p);
	print(p);
}

void BFS() {
	s.a = s.b = 0;
	s.sign = 0;
	t.a = t.b = C;
	int i = mi;	//mp的指针

	mp.clear();//清空mp
	while (!Q.empty())//清空队列，因为多组数据可能会产生冲突
		Q.pop();

	Q.push(s);
	mp[s] = ++i;//指针后移
	cup final;
	while (!Q.empty()) {
		cup now = Q.front();
		Q.pop();

		if (now.a < A) {//fill A
			cup n = now;
			fillA(n);

			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 1;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.b < B) {//fill B
			cup n = now;
			fillB(n);
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 2;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.a != 0 && now.b != 0) {//empty A or B
			cup n1 = now;
			emptyA(n1);
			if (mp.count(n1) == 0) {//n1不在mp中
				n1.sign = 3;//sign记录n1是经过了什么操作
				//cout << n1.sign << endl;
				Q.push(n1);
				mp[n1] = ++i;//指针后移
				parent[mp[n1]] = now;//n1的父节点是now，而mp[n1]则是其指针
			}
			if (n1 == t) {//判定是否到达终点
				final = n1;
				break;
			}
			cup n2 = now;
			emptyB(n2);
			if (mp.count(n2) == 0) {//n2不在mp中
				n2.sign = 4;//sign记录n2是经过了什么操作
				//cout << n2.sign << endl;
				Q.push(n2);
				mp[n2] = ++i;//指针后移
				parent[mp[n2]] = now;//n2的父节点是now，而mp[n2]则是其指针
			}
			if (n2 == t) {//判定是否到达终点
				final = n2;
				break;
			}
		}
		if (now.b != B && now.a != 0) {//pour A B
			cup n = now;
			AtoB(n);
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 5;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
		if (now.a != A && now.b != 0) {//pour B A
			cup n = now;
			BtoA(n);
			if (mp.count(n) == 0) {//n不在mp中
				n.sign = 6;//sign记录n是经过了什么操作
				//cout << n.sign << endl;
				Q.push(n);
				mp[n] = ++i;//指针后移
				parent[mp[n]] = now;//n的父节点是now，而mp[n]则是其指针
			}
			if (n == t) {//判定是否到达终点
				final = n;
				break;
			}
		}
	}
	fprint(final);//打印操作
	print(final);
	cout << "success" << endl;
	//cout << "( " << final.a << " , " << final.b << " )" << endl;
}




int main() {

	while (~scanf_s("%d%d%d", &A, &B, &C)) {//VS中是scanf_s，和scanf效果相同
		BFS();
	}
	return 0;
}
XiaoAnnOVO
关注
专栏目录
Water_Pouring1_注水算法_mimo_
10-04
这是用于MIMO闭环信道计算信道遍历容量的注水算法
Pouring water
sandra
03-18 1100
#include #include #include #define MAX 10000000 using namespace std; int f[201][201][201];//用来存放到达某个状态所需倒的最少水量 short inQ[201][201][201];//用来标记某个状态是否在队列中 int main() { queue q; short s[3], d;
《Algorithms》习题之 Pouring water
永不放弃的地盘
11-11 3231
习题原文： Pouring water. We have three containers whose sizes are 10 pints, 7 pints, and 4 pints, re-spectively. The 7-pint and 4-pint containers start out full of water, but the 10-pint container is ini
NYOJ 21 图的广度优先搜索 倒水问题
坤哥的专栏
10-26 1410
题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=21 思路： 算法竞赛入门经典中该题有思路分析，该题是隐式图的遍历，每次三个杯子中的状态可以看成一个结点，通过几种倒水的方式，推出下一层的结点，以此例推，可得出解。 这里需要解决的问题： 1，怎样解决倒水 A：通过模拟，由于没有刻度，每次倒水只能倒满，而且倒水的容量取决于容器的最大
程序设计思维 B - Pour Water（广度优先搜索）
weixin_43826681的博客
03-06 154
题目 倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。 Input 输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <= 1000 、A和B互质。 Output 你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子...
代码 基于BFS广度优先搜索算法代码
06-04
代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 基于BFS广度优先搜索算法代码代码 ...
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
本资源“MATLAB源码集锦-基于BFS广度优先搜索算法代码”是专门为MATLAB用户提供的，旨在帮助他们理解和实现BFS算法。 BFS算法的基本思想是从起点开始，首先访问其所有邻居，然后访问这些邻居的邻居，以此类推，直到...
BFS 广度优先搜索算法 matlab
03-19
广度优先搜索（Breadth-First Search，简称BFS）是一种在图或树数据结构中遍历或搜索节点的经典算法。在MATLAB环境中实现BFS，可以帮助我们解决许多实际问题，如网络路由、社交网络分析、游戏状态搜索等。本程序的...
广度优先算法、最佳优先算法、A*算法寻路程序
06-21
本项目重点介绍了三种常见的寻路算法：广度优先算法（Breadth-First Search, BFS）、最佳优先算法（Best-First Search）以及A*（A-star）算法，并通过C++语言在Visual Studio 2015环境下实现，使用MFC库进行可视化...
BFS.rar_Bfs算法_bfs_广度优先_广度搜索算法_搜索算法
09-24
**广度优先搜索（BFS）算法详解** 广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。它从根节点开始，然后遍历所有相邻的节点，然后再对每个相邻节点进行相同的操作，直到遍历完所有节点。在图中，BFS算法...
三个水壶水壶问题（广度优先java实现）
04-15
有一个充满水的8品脱的水壶和两个空水壶（容积分别是5品脱和3品脱）。通过将水壶完全倒满水和将水壶的水完全倒空这两种方式，在其中的一个水壶中得到4品脱的水。
作业1.2 Pour Water (BFS)
pgsld2333的博客
03-03 272
题目大意 倒水问题。 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。 输入 包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。 输出 你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单位的水。每组...
Leetcode 755: 倒水 Pour Water
weixin_43946031的博客
04-14 300
题目描述： We are given an elevation map, heights[i] representing the height of the terrain at that index. The width at each index is 1. After V units of water fall at index K, how much water is at each index? Water first drops at index K and rests on top of t
bfs-倒水
容容容的博客
03-06 283
Title:有两个容量为A，B的空杯，以及不限量的水。经过一系列对A和B的操作使任意一杯的水量为C。操作包括：“fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。对B同理，即共有6种操作。 Input:输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B &lt...
BFS+优先队列：PIPI倒水
qq_44709990的博客
09-27 224
BFS+优先队列：PIPI倒水 问题： 思路：   此题为隐式图BFS题。设三个杯子分别为a,b,c，则状态转移的数目为6，我们可以将水从a倒入b,c；也可将水从b倒入a,c;也可将水从c倒入a,b；题中要求最少倒水量，而非最少操作数，因此我们可以使用优先队列，优先遍历倒水量少的状态。用一个大小为3的一维数组表示三个杯子的水量，连同总倒水量一起作为状态加入队列中。   如何处理每次倒水，要么将倒出的杯子的水倒空，要么将倒入的杯子倒满？设由编号i的杯子倒水入编号j的杯子，i和j的水量分别为w[i],w[j
利用BFS解决倒水问题
txzhangZz的博客
03-03 727
题意 倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。 Input 输入包含多组数据。每组数据输入 A, B, C 数据范围 0 < A <= B 、C <= B <=1000 、A和B互质。 Output 你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单...
POJ-3414 Pots
sdudyl的博客
03-18 123
POJ-3414 Pots You are given two pots, having the volume of A and B liters respectively. The following operations can be performed: FILL(i) fill the pot i (1 ≤ i ≤ 2) from the tap; DROP(i) empty the pot i to the drain; POUR(i,j) pour from pot i to po
BFS（宽度优先搜索）问题 A: Jugs 。倒水问题
qq_20679687的博客
04-23 922
时间限制:1 Sec内存限制:32 MB 提交:222解决:0 [提交][状态][讨论版][命题人:外部导入] 题目描述 In the movie "Die Hard 3", Bruce Willis and Samuel L. Jackson were confronted with the following puzzle. They were given a 3-gall...
倒水问题 （BFS搜索问题）
G_12_M的博客
05-15 1990
题目描述 Description时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 有两个无刻度标志的水壶，分别可装 x 升和 y 升 （ x,y 为整数且均不大于 100 ）的水。设另有一水 缸，可用来向水壶灌水或接从水壶中倒出的水， 两水壶间，水也可以相互倾倒。已知 x 升壶为空 壶， y 升壶为空壶。问如何通过倒水或灌水操作， 用最少步数...
C语言实现广度优先搜索与A*算法解决8数码问题
在本实验中，我们将通过C语言实现两种搜索策略：广度优先搜索（BFS）和A*搜索算法，并将它们应用于解决8数码问题（8-puzzle）。以下将详细介绍相关知识点： 一、广度优先搜索（BFS）算法： 1. 基本概念：BFS是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值