Week2作业——搜索/隐式图问题

Week2-作业练习

---

github同步

Problem A

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

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

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

思路：

• 考虑到最短路线，因此使用BFS
• 关键在于路径的输出。首先考虑利用BFS寻找路径，在此过程中记录路径，最后进行输出。具体记录的方式是每一个点记录其前序节点，最后从目标点返回即可。

实现：

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

struct point{int x,y;};
int mx[4]={-1,1,0,0};//上下左右 
int my[4]={0,0,-1,1};
bool vis[5][5]={0};//0表示未到达，1表示已到达/不能到达 
point pre[5][5];//记录前序节点

int main()
{
	int a;
	for(int i=0;i<5;++i)
	for(int j=0;j<5;++j)
	{
		cin>>a;
		vis[i][j]=a;
	}
	point start,next,tmp;
	start.x=0,start.y=0; 
	
	pre[0][0].x=-1,pre[0][0].y=-1;
	queue<point> q;
	q.push(start);
	vis[0][0]=1;
	while(!q.empty())
	{
		tmp=q.front();
		if(tmp.x==4 && tmp.y==4)
		break;
		q.pop();
		for(int i=0;i<4;++i)
		{
			int x=tmp.x+mx[i];
			int y=tmp.y+my[i];
			if(x>=0 && x<=4 && y>=0 && y<=4 && vis[x][y]==0)
			{
				vis[x][y]=1;
				next.x=x,next.y=y;
				pre[x][y].x=tmp.x;
				pre[x][y].y=tmp.y;
				q.push(next);
			}
		}
	}	
	//使用头插法保存路径
	list<point> res;
	res.push_front(tmp); 
	point now;
	now.x=pre[tmp.x][tmp.y].x;
	now.y=pre[tmp.x][tmp.y].y;
	while(now.x!=-1 && now.y!=-1)
	{
		res.push_front(now);
		int n = now.x;
		now.x=pre[now.x][now.y].x;
		now.y=pre[n][now.y].y;		
	}
	list<point>::iterator ia=res.begin();
	for(;ia!=res.end();ia++)
		cout<<"("<<ia->x<<", "<<ia->y<<")"<<endl; 
	return 0;
}

反思：

出现BUG，发现尽管pre数组中每个元素都正确，但是最后从终点返回输出时却偶尔发生错误：丢失某些点。仔细排查发现是连续借助now.x赋值时，由于第一次赋值将其改变导致第二次赋值错误。错误代码如下：

	cout<<"("<<now.x<<", "<<now.y<<")"<<endl; 
	res.push_front(now);
	now.x=pre[now.x][now.y].x;
	now.y=pre[now.x][now.y].y;	

Problem B

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

思考：

• 基本思路还是上课时的方法，初始状态放入队列，之后由一种状态可以得到六种状态，类似于BFS当中由一点进行延伸；当然这里还需要判断状态是否已经出现过；
• 对于输出的考虑：不同于课上的例题，这里我们必须输出具体的操作过程，所以考虑在将状态入队时使用string记录操作过程，并且建立映射status->string同时，类似于上题，我们需要将状态的转移变化记录下来——类似的思路：记录每一状态的前序状态；具体的数据结构使用map<status,status>,map<status,string>,map<status,bool>

实现：

#include<iostream>
#include<string>
#include<map>
#include<queue>

using namespace std;

struct status
{
	int x,y;
	status(){};
	status(int x1,int y1)
	{
		x=x1;
		y=y1;
	};
	
	bool operator<(const status &s) const 
	{
		return x!=s.x ? x<s.x : y<s.y;
	}
};

map<status,status> pre;
map<status,string> pre_op;
map<status,bool> vis;//注意默认为0 
queue<status> q;
void print(status s)
{//递归输出
	if(pre.find(s) != pre.end())
		print(pre[s]);
		cout<<pre_op[s]<<endl;

}

void bfs(int a,int b,int c)
{
	status start(0,0);
	q.push(start);
	while(!q.empty())
	{
		status tmp = q.front();
		vis[tmp]=1;
		q.pop();
		if(tmp.x==c || tmp.y==c)
		{
			print(tmp);
			return;
		}
		
		//将A杯倒空
		if(tmp.x > 0)
		{
			status next(0,tmp.y);
			if(vis[next]==0)
			{
				vis[next]=1;
				q.push(next);
				pre[next]=tmp;
				pre_op[next]="empty A";
			}		
		 } 
		 
		 //将B杯倒空
		 if(tmp.y > 0)
		 {
		 	status next(tmp.x,0);
		 	if(vis[next]==0)
		 	{
		 		vis[next]=1;
		 		q.push(next);
		 		pre[next]=tmp;
		 		pre_op[next]="empty B";
			 }
		  } 
		  
		//将A杯倒入B杯,如果B杯满则停止 
		//注意前提是A杯有水，否则状态必然重复
		if(tmp.x > 0)
		{
			status next;
			next.y=min(b,tmp.y+tmp.x);
			next.x=max(0,tmp.y+tmp.x-b);
			if(vis[next]==0)
			{
				vis[next]=1;
				q.push(next);
				pre[next]=tmp;
				pre_op[next]="pour A B";
			}
		 }
		 
		 if(tmp.y >0)
		 {
		 	status next;
		 	next.x=min(a,tmp.y+tmp.x);
		 	next.y=max(0,tmp.y+tmp.x-a);
		 	if(vis[next]==0)
		 	{
		 		vis[next]=1;
		 		q.push(next);
		 		pre[next]=tmp;
		 		pre_op[next]="pour B A";
			 }
		  } 
		  
		  //A杯未满则倒满
		  if(tmp.x < a)
		  {
		  	status next(a,tmp.y);
		  	if(vis[next]==0)
		 	{
		 		vis[next]=1;
		 		q.push(next);
		 		pre[next]=tmp;
		 		pre_op[next]="fill A";
			 }
		   } 
		   
		   if(tmp.y < b)
		   {
		   	status next(tmp.x,b);
		   	if(vis[next]==0)
		 	{
		 		vis[next]=1;
		 		q.push(next);
		 		pre[next]=tmp;
		 		pre_op[next]="fill B";
			 }
		   }	
	}
}

int main()
{
	int a,b,c;
	while(cin>>a>>b>>c)
	{
		pre.clear();
		pre_op.clear();
		vis.clear();
		while (!q.empty())q.pop();
		bfs(a,b,c);
		cout<<"success"<<endl;
	}	
	return 0;
}

反思：

• 对于多组数据的处理，需要考虑数据结构清空
• 一般对于BFS之后目标路径的输出有两种方法，一种是直接递归，另一种是先存储再输出，当然他们的前提都是在BFS的过程中执行路径的记录——常见方法是记录每个节点的前序节点。
• 对于STL中各结构的使用不够熟练，经常需要百度。