Week2作业maze+pour water【bfs】

A-maze

题目描述

东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线

Input

输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。

Output

输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样例所示。数据保证有唯一解。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 1 0 1 0
0 0 0 1 0
0 1 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(3, 0)
(3, 1)
(3, 2)
(2, 2)
(1, 2)
(0, 2)
(0, 3)
(0, 4)
(1, 4)
(2, 4)
(3, 4)
(4, 4)

Hint

坐标(x, y)表示第x行第y列，行、列的编号从0开始，且以左上角为原点。
另外注意，输出中分隔坐标的逗号后面应当有一个空格。

题解

• 整数型数组dx和dy用来遍历到达点的相邻四个点；二维数组vis用来记录点(i，j)是否被到达过，不可到达（有障碍物）为-1，未到达为0，已到达为1；二维数组last_x、last_y经过点（i，j）时的上一个点的横坐标和纵坐标，用来记录路径。
• 本题采用广度优先搜索的思想，借助队列结构，将已到达的点放入队列，循环逐个取出，遍历取出的点的相邻点，若能达到且未到达则放入队列修改相应数据；就这样 ，从出发点开始，逐层向外扩展，直至扩展到找到目标点。
  -代码还有很多不足之处，如路径的表示等还有很多可以优化的地方。

总结

该问题是bfs图问题，给出初始节点、目标节点、扩展规则和具体的图，要求找出从初始节点到目标节点的最短距离。

代码

#include <iostream>
#include <cstdio>
#include <queue>
#include <map>
using namespace std;
struct point {
	int x, y;//点坐标 
};
queue<point> q;
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
int maze;
int vis[5][5];
int last_x[5][5];//经过点（i，j）时的上一个点的横坐标
int last_y[5][5];//经过点（i，j）时的上一个点的纵坐标
int sx = 0, sy = 0;//源点坐标
int tx = 4, ty = 4;//终点坐标 
void bfs() {
	q.push({ sx,sy });
	vis[sx][sy] = true;
	while (!q.empty()) {
		point now = q.front();
		q.pop();
		for (int i = 0; i < 4; i++) {
			int new_x = now.x + dx[i], new_y = now.y + dy[i];
			if (new_x >= 0 && new_x < 5 && new_y >= 0 && new_y < 5 &&
				vis[new_x][new_y] == 0) {
				point tmp = { new_x,new_y };
				q.push(tmp);
				last_x[new_x][new_y] = now.x;
				last_y[new_x][new_y] = now.y;
				vis[new_x][new_y] = 1;
			}
			if (new_x == tx && new_y == ty) {
				return;
			}
		}
	}
}

int main(int argc, char** argv) {
	for (int i = 0; i < 5; i++) {
		for (int j = 0; j < 5; j++) {
			scanf("%d", &maze);
			//getchar();
			if (maze == 1) {
				vis[i][j] = -1;
			}
			else {
				vis[i][j] = 0;
			}
			last_x[i][j]=0;
			last_y[i][j]=0;
		}
	}
	bfs();
	int routex[25];
	int routey[25];
	int n = 0;
	routex[n] = tx;
	routey[n++] = ty;
	while (routex[n - 1] != sx || routey[n - 1] != sy) {
		int m = n-1;
		routex[n] = last_x[routex[m]][routey[m]];
		routey[n++] = last_y[routex[m]][routey[m]];
	}
	for (int i = n - 1; i >= 0; i--) {
		cout << "(" << routex[i] << ", " << routey[i] << ")" << endl;
	}
	return 0;
}

B-Pour water

题目描述

倒水问题 “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单位的水。每组数据的最后一行输出应该是“success”。输出行从第1列开始，不应该有空行或任何尾随空格。

Sample Input

2 7 5
2 7 4

Sample Output

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

Notes

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

题解

• 结构体status记录的是两杯水的状态，a、b表示当前A、B杯中的水量；结构体record记录的是from状态是如何到达to状态的，way为0表示倒空A杯可从from状态到to状态，way为1表示倒空B杯，way为2表示倒满A杯，way为3表示倒满B杯，way为4表示把A的水倒到B杯并且把B杯倒满或A倒空，way为5表示把B的水倒到A杯并且把A杯倒满或B倒空；二维字符型数组way则是对应以上数字的方法的输出形式，输出way[i]即可输出相应字符串；二维布尔型数组reach记录状态(a=i,b=j)是否到达过；n记录re中元素个数；m记录ans中元素个数
• 首先将所有的数组型元素赋初值，并清空队列。
• bfs时，借助队列，将初状态放入队列，然后循环以下步骤：若队列不为空，取出队列首元素q ，判断是否有杯中的水为c，不是则按照条件进行两个水杯间的6种操作（倒满，倒空…），每进行完一种操作，就判断达到的水的状态有没有达到过，没有就将该状态放入队列，并修改相应的re数组、reach数组。循环进行至找到杯中水量为c的状态，并返回该状态。
• 输出时，通过一个循环遍历re数组的n-1到0，因为后达到的状态一定在re数组的后面，所以遍历一遍即可，找出相关的way并记录到ans中。最后从后往前输出ans中的数字对应的操作的字符串。

总结

该问题是bfs隐式图问题，给出初始状态、目标状态、扩展规则，要求找出从初始状态到最终状态的最快方式。

代码

#include <iostream>
#include <cstdio>
#include <queue>
#include <map>
using namespace std;
struct status {//水的状态 
	int a,b;//a,b中的水量
	bool operator <(const status p) {
		return (a!=p.a)? a<p.a:b<p.b;
	}
	bool operator ==(const status p) {
		return a==p.a&&b==p.b;
	}
};
struct record {//从from状态如何到达to状态 
	status from,to;
	int way; //0:倒空A,1:倒空B,2:倒满A,3:倒满B,4:从A倒入B,5:从B倒入A
};
char way[7][12]={"empty A","empty B","fill A","fill B","pour A B","pour B A"};
record*re;
int n=0;//记录re用了多少个 
queue<status> q;//bfs
int aa,bb,cc;//容量和要求的水量 
bool**reach;//记录各状态是否到达过 

status bfs(){      
	status s={0,0},t;
	reach[0][0]=1;
	q.push(s);
	while(!q.empty()){
		s=q.front();
		q.pop();
		//判断是否是终点 
		if(s.a==cc||s.b==cc){
			//cout<<"reach this?"<<endl;
			return s;
		}
		//0:倒空A
		if(s.a!=0){
			t.a=0;
			t.b=s.b;
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,0}; 
			}
		} 
		//1:倒空B	
		if(s.b!=0){
			t.a=s.a;
			t.b=0;
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,1}; 
			}
		} 
		//2:倒满A	
		if(s.a!=aa){
			t.a=aa;
			t.b=s.b;
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,2}; 
			}
		} 
		//3:倒满B	
		if(s.b!=bb){
			t.a=s.a;
			t.b=bb;
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,3}; 
			}
		} 
		//4:从A倒入B
		if(s.a!=0&&s.b!=bb){
			if(s.a<=bb-s.b) {
				t.a=0;
				t.b=s.a+s.b;
			}else{
				t.b=bb;
				t.a=s.a+s.b-bb;
			}
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,4}; 
			}
		}
		//5:从B倒入A
		if(s.b!=0&&s.a!=aa){
			if(s.b<=aa-s.a) {
				t.b=0;
				t.a=s.a+s.b;
			}else{
				t.a=aa;
				t.b=s.b+s.a-aa;
			}
			if(reach[t.a][t.b]==0){
				reach[t.a][t.b]=1;
				q.push(t);
				re[n++]={s,t,5}; 
			}
		}
	} 
}
int main(int argc, char** argv) {
	while(scanf("%d %d %d",&aa,&bb,&cc)!=EOF) {
		re=new record[(aa+1)*(bb+1)];
		reach=new bool*[aa+1];
		for(int i=0;i<=aa;i++){
			reach[i]=new bool[bb+1];
			for(int j=0;j<bb+1;j++){
				reach[i][j]=0;
			}
		}
		n=0;
		while(!q.empty()){q.pop();}
		status t=bfs();
		int ans[aa*bb];
		int m=0;//记录ans中的元素个数 
		for(int i=n-1;i>=0;i--){
			if(re[i].to==t){
				t=re[i].from;
				ans[m++]=re[i].way;
			}
		} 
		for(int i=m-1;i>=0;i--){
			cout<<way[ans[i]]<<endl;
		}
		cout<<"success"<<endl;
	}
	return 0;
}