【SeedCoder2015年热身题6 搜索】Move Game (题目)

最新推荐文章于 2016-02-14 00:33:19 发布

原创最新推荐文章于 2016-02-14 00:33:19 发布 · 719 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#搜索

本文介绍了一款基于3x3网格的游戏，玩家通过上下左右移动不同颜色的小球到达目标位置。文章详细解释了如何使用宽度优先搜索算法来找出解决这个游戏的最少移动步数，并提供了完整的C++代码实现。

【问题】

现有如下一款游戏，游戏的目的是通过”左，右，上，下”滑动来移动红，绿，蓝色的小球，每操作一次所有小球最多只能移动一步(与2048不同)，其中灰色区域块为禁止区域，小球不能移动到该位置。若所有有色小球停留在对应的色区块下，则游戏结束。那么对于该游戏关卡，最少需要多少步才能完成。

【输入】

输入只由一组测试样例组成。该样例由两部分组成，第一部分为3×3的矩阵，矩阵每一行占据一列，每个数之间以Tab键隔开；其中0表示该单元未被小球和灰色壁垒占据，-1表示该单元被灰色壁垒占据，1表示被红色小球占据，2表示被绿色小球占据，3表示被蓝色小球占据；第二部分表示红，绿，蓝色块的位置，第一行表示红色色块的位置，第二行表示绿色色块的位置，第三行表示蓝色色块的位置。数字之间以Tab键隔开。

【输出】

对于每一次输出样例，输出最小的操作数。

【示例输入】

1 0 -1

3 2 0

-1 -1 0

1 2

0 1

0 0

--------------------------------------------------------------------------------------------------------------------------------------------------

【解答】

该题目与上一道题目类似，都是利用宽度优先搜索。该示例代码未按照指定格式进行输出，输出了最短操作步骤，可以直接按照输出步骤完成该游戏。

//--------------------------------------【程序说明】-------------------------------------------
//		程序说明：上上下下ABAB
//		程序描述：搜索
//		IDE版本：Visual Studio 2013
//		作者：Arthur Lee
//------------------------------------------------------------------------------------------------  

//【1】头文件
#include <fstream>
#include <ctime>
#include <list>
#include <functional>//包含less<>等仿函数
#include <algorithm>
#include <deque>//包含deque类
using namespace std;

#define TIMER
//【2】函数声明
void InitialData();
bool BreadthFirstSearch();
//【3】定义枚举体，在几种方法中切换
enum Method
{
	BreadthFirst
};
enum Action{
	Left,Right,
	Up,Down
};
enum Color{
	Red=1,Green,Blue
};
class Point {
public:
	int x;
	int y;
	Point(){
		x = 0;
		y = 0;
	}
	Point(int x0, int y0) :x(x0), y(y0){}
	//Point(Point& p) :x(p.x), y(p.y){}
	bool operator ==(Point pos){
		return (x == pos.x&&y == pos.y);
	}
	bool operator !=(Point pos){
		return !(*this == pos);
	}
	Point& operator = (const Point& p){
		this->x = p.x;
		this->y = p.y;
		return *this;
	}
};

Point PosTemp[3];//全局Point变量，类实现需要放在这之前

//定义的判断准则
bool CompareWithX_IndexIncrease(const int& x1, const int& x2){
	return less<int>()(PosTemp[x1].x, PosTemp[x2].x);
}
bool CompareWithX_IndexDecrease(const int& x1, const int& x2){
	return greater<int>()(PosTemp[x1].x, PosTemp[x2].x);
}
bool CompareWithY_IndexIncrease(const int& x1, const int& x2){
	return less<int>()(PosTemp[x1].y, PosTemp[x2].y);
}
bool CompareWithY_IndexDecrease(const int& x1, const int& x2){
	return greater<int>()(PosTemp[x1].y, PosTemp[x2].y);
}
class State{
public:
	static Point FinalPoint[3];
	int Board[3][3];//游戏面板，0表示无占据，Red，Green,Blue表示有点占据。-1表示障碍物占据
	Point InitialPoint[3];//R,G,B
	list<Action> Routine;

	State& operator =(const State& s){
		for (int i = 0; i < 3; ++i)
			for (int j = 0; j < 3; ++j)
				this->Board[i][j] = s.Board[i][j];
		for (int i = 0; i < 3; ++i){
			this->InitialPoint[i] = s.InitialPoint[i];
		}
		this->Routine = s.Routine;
		return *this;
	}
	bool IsFinalState(){
		int i = 0;
		for (; i < 3; ++i){
			if (InitialPoint[i] != FinalPoint[i])
				break;
		}
		if (i < 3)
			return false;
		else
			return true;
	}
	bool operator == (State s){
		int i = 0;
		for (; i < 3; ++i){
			if (InitialPoint[i] != s.InitialPoint[i])
				break;
		}
		if (i < 3)
			return false;
		else
			return true;
	}

	bool MoveOneStep(Action act, State& result){//NOTE:为保证修改形参Result,该函数必须以State&作为参数~~！！
		int Order[3] = { 0, 1, 2 };//0 - Red,1-Green,2-Blue;表示三者排序指标
		for (int i = 0; i < 3; ++i)
			PosTemp[i] = InitialPoint[i];
		result = *this;//result 储存转换后的最终的结果
		bool flag = false;//表示MoveOneStep 是否改变了状态。
		switch (act)
		{
		case Left:
			sort(Order, Order + 3, CompareWithY_IndexIncrease);
			for (int i = 0; i < 3; ++i){
				if (InitialPoint[Order[i]].y >= 1 && 
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y - 1] == 0)
				{
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y] = 0;
					result.InitialPoint[Order[i]].y -= 1;
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y - 1] = (Order[i] + 1);
					flag = true;
				}
			}
			break;
		case Right:
			sort(Order, Order + 3, CompareWithY_IndexDecrease);
			for (int i = 0; i < 3; ++i){
				if (InitialPoint[Order[i]].y<2 && 
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y + 1] == 0)
				{
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y] = 0;
					result.InitialPoint[Order[i]].y += 1;
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y + 1] = (Order[i] + 1);
					flag = true;
				}
			}
			break;
		case Up:
			sort(Order, Order + 3, CompareWithX_IndexIncrease);
			for (int i = 0; i < 3; ++i){
				if (InitialPoint[Order[i]].x >= 1 && 
					result.Board[InitialPoint[Order[i]].x - 1][InitialPoint[Order[i]].y] == 0)
				{
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y] = 0;
					result.InitialPoint[Order[i]].x -= 1;
					result.Board[InitialPoint[Order[i]].x - 1][InitialPoint[Order[i]].y] = (Order[i] + 1);
					flag = true;
				}
			}
			break;
		case Down:
			sort(Order, Order + 3, CompareWithX_IndexDecrease);
			for (int i = 0; i < 3; ++i){
				if (InitialPoint[Order[i]].x <2 && 
					result.Board[InitialPoint[Order[i]].x + 1][InitialPoint[Order[i]].y] == 0)
				{
					result.Board[InitialPoint[Order[i]].x][InitialPoint[Order[i]].y] = 0;
					result.InitialPoint[Order[i]].x += 1;
					result.Board[InitialPoint[Order[i]].x + 1][InitialPoint[Order[i]].y] = (Order[i] + 1);
					flag = true;
				}
			}
			break;
		default:
			break;
		}
		return flag;
	}

};
Point State::FinalPoint[3] = {};
//【4】变量声明
bool IsExistInHashTable(State);
deque<State> HashTable;//充当hashtable 的功能
State InitialState;
State Result;//存放最终的结果

int main(){
#ifdef TIMER
	clock_t start = clock();
#endif // TIMER
	ifstream fin("in.txt");
	if (fin.fail())
		return 1;
	ofstream fout("out.txt");
	Method method = Method::BreadthFirst;
	bool flag = false;
	while (!fin.eof())
	{
		InitialData();
		for (int i = 0; i < 3; ++i)
			for (int j = 0; j < 3; ++j){
				fin >> InitialState.Board[i][j];
				switch (InitialState.Board[i][j])
				{
				case 1://红色
					InitialState.InitialPoint[0].x = i;
					InitialState.InitialPoint[0].y = j;
					break;
				case 2://绿色
					InitialState.InitialPoint[1].x = i;
					InitialState.InitialPoint[1].y = j;
					break;
				case 3:
					InitialState.InitialPoint[2].x = i;
					InitialState.InitialPoint[2].y = j;
					break;
				default:
					break;
				}
			}
		fin >> State::FinalPoint[0].x >> State::FinalPoint[0].y
			>> State::FinalPoint[1].x >> State::FinalPoint[1].y
			>> State::FinalPoint[2].x >> State::FinalPoint[2].y;
		switch (method)
		{
		case BreadthFirst:
			flag = BreadthFirstSearch();
			break;
		default:
			break;
		}

		if (flag)//输出
		{
			fout << "the smallest steps to achieve the goal is " << Result.Routine.size() << "\n";
			while (!Result.Routine.empty())
			{
				switch (Result.Routine.front())
				{
				case Left:
					fout << "left" << "\t";
					break;
				case Right:
					fout << "right" << "\t";
					break;
				case Up:
					fout << "up" << "\t";
					break;
				case Down:
					fout << "down" << "\t";
					break;
				default:
					break;
				}
				Result.Routine.pop_front();
			}
		}
		else
			fout << "there is no answer!" << "\n";

		fout << "\n";
	}
	
#ifdef TIMER
	clock_t end = clock();
	double duration = (double)(end - start);
	fout << "runtime : " << duration << "ms" << endl;
#endif // TIMER
	fout.close();
	return 0;
}


//【5】函数实现
void InitialData(){
	HashTable.clear();
}

bool BreadthFirstSearch(){
	list<State> list_temp;
	State temp;
	list_temp.push_back(InitialState);
	HashTable.push_back(InitialState);

	while (!list_temp.empty()){
		temp = list_temp.front();
		list_temp.pop_front();

		for (int i = 0; i < 4; ++i){
			if (temp.MoveOneStep((Action)i, Result)){
				if (!IsExistInHashTable(Result)){
					Result.Routine.push_back((Action)i);
					list_temp.push_back(Result);
					HashTable.push_back(Result);
					if (Result.IsFinalState())
						return true;
				}
			}
		}
	}
	return false;
}

bool IsExistInHashTable(State s){
	for (int i = 0; i < HashTable.size(); ++i){
		if (HashTable[i] == s)
		{
			return true;
		}
	}
	return false;
}