pku acm 1077

最新推荐文章于 2013-09-09 15:32:19 发布
最新推荐文章于 2013-09-09 15:32:19 发布
阅读量629 收藏
点赞数
分类专栏： POJ ACM 文章标签： iterator string 算法 class null struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xudacheng06/article/details/6798668
版权

非常经典的8数码问题，主要采用的算法是人工智能中的“有序搜索算法”，也有人称之为A算法。


#include <iostream>
#include <cstdio>
#include <algorithm>
#include <set>
#include <string>
using namespace std;

const int LEN = 9;
struct  PStatus
{
	string pos;//位置信息
	int index;//'x'的坐标位置
	PStatus *parent;//指向父状态
	char direction;//l,r,u,d

	int height;//高度
	int f;//f值
};

PStatus bStatus;
PStatus gStatus = {"12345678x"};

int getWrongPoses(string pos)//错放棋子个数
{
	int sum = 0;
	for (int i = 0; i < pos.size(); ++i)	
		if (gStatus.pos[i] != pos[i])
			sum++;	
	return sum;
}

bool cmp1(PStatus* first,PStatus* second)
{
	int r = first->pos.compare(second->pos);
	if (r < 0)return false;
	if (r > 0)return true;
	return false;
}
set<PStatus*,bool (*)(PStatus* ,PStatus* )> closed(cmp1);

bool cmp2(PStatus* first,PStatus* second)
{
	if (first->f < second->f)return true;
	if (first->f > second->f)return false;
	return false;
}
multiset<PStatus*,bool (*)(PStatus* ,PStatus* )> open(cmp2);

bool isInClosed(PStatus* status)
{
	if (closed.find(status) != closed.end())return true;	
	return false;
}

bool isInOpen(PStatus* status)
{
	multiset<PStatus*,bool (*)(PStatus* ,PStatus* )>::iterator it = open.begin();
	for (; it != open.end(); ++it)
		if (status->pos == (*it)->pos)
			return true;
	return false;
}

string bfs()
{
	PStatus *ps,*np;
	int i;
	open.insert(&bStatus);

	while (open.size() > 0)
	{
		ps = *open.begin();
		if (ps->pos == gStatus.pos)//找到答案
		{
			string result = "";
			while(ps != NULL)
			{
				if (ps->direction != 'z')
					result = ps->direction + result;
				ps = ps->parent;
			}
			return result;
		}		

		open.erase(open.begin());
		closed.insert(ps);
		
		for (i = 0; i < 4; ++i)
		{
			switch(i)
			{
			case 0://left
				if (ps->direction != 'r' && ps->index%3 != 0)
				{
					np = new PStatus;
					np->pos = ps->pos;
					swap(np->pos[ps->index], np->pos[ps->index-1]);
					if (!isInClosed(np) && !isInOpen(np))
					{
						np->parent = ps;
						np->index = ps->index - 1;
						np->direction = 'l';

						//np->height = ps->height + 1;
						//np->f = np->height + getWrongPoses(np->pos);
						np->f = getWrongPoses(np->pos);

						open.insert(np);
					}
					else
						delete np;					
				}
				break;
			case 1://right
				if (ps->direction != 'l' && ps->index%3 != 2)
				{
					np = new PStatus;
					np->pos = ps->pos;
					swap(np->pos[ps->index], np->pos[ps->index+1]);
					if (!isInClosed(np) && !isInOpen(np))
					{
						np->parent = ps;
						np->index = ps->index+1;
						np->direction = 'r';

						//np->height = ps->height + 1;
						//np->f = np->height + getWrongPoses(np->pos);
						np->f = getWrongPoses(np->pos);

						open.insert(np);
					}
					else
						delete np;	
				}
				break;
			case 2://up
				if (ps->direction != 'd' && (ps->index - ps->index%3) > 2)
				{
					np = new PStatus;
					np->pos = ps->pos;
					swap(np->pos[ps->index], np->pos[ps->index-3]);
					if (!isInClosed(np) && !isInOpen(np))
					{
						np->parent = ps;
						np->index = ps->index - 3;
						np->direction = 'u';

						//np->height = ps->height + 1;
						//np->f = np->height + getWrongPoses(np->pos);
						np->f = getWrongPoses(np->pos);

						open.insert(np);
					}
					else
						delete np;	
				}
				break;
			case 3://down
				if (ps->direction != 'u' && ps->index  < 6)
				{
					np = new PStatus;
					np->pos = ps->pos;
					swap(np->pos[ps->index], np->pos[ps->index+3]);
					if (!isInClosed(np) && !isInOpen(np))
					{
						np->parent = ps;
						np->index = ps->index +3;
						np->direction = 'd';

						//np->height = ps->height + 1;
						//np->f = np->height + getWrongPoses(np->pos);
						np->f = getWrongPoses(np->pos);

						open.insert(np);
					}
					else
						delete np;	
				}
				break;
			}
		}		
	}

	return "unsolvable";
}


//两个状态之间是否可达，可以通过计算两者的逆序值，若两者奇偶性相同则可达，不然两个状态不可达
bool solvable(string pos,int index)
{
	pos.erase(index,1);
	int sum = 0;
	for (int i = 1; i < pos.size(); ++i)
	{
		for (int j = 0; j < i; ++j)
			if (pos[i] < pos[j])
				sum += 1;		
	}
	if (sum%2 == 0)return true;
	else return false;
}

int main()
{
	freopen("in.txt","r",stdin);
	char ch;
	for (int i = 0; i < LEN; ++i)
	{
		cin>>ch;
		bStatus.pos += ch;
		if (ch == 'x')bStatus.index = i;		
	}		

	if(!solvable(bStatus.pos,bStatus.index))
		cout<<"unsolvable"<<endl;
	else
	{
		bStatus.parent = NULL;
		bStatus.direction = 'z';//没有方向
		bStatus.height = 0;
		bStatus.f = getWrongPoses(bStatus.pos) + bStatus.height;
		cout<<bfs()<<endl;
	}
	
}

测试数据

2 3 4 1 5 x 7 6 8

1 2 3 7 6 4 8 x 5

1 2 3 7 x 4 8 6 5

1 2 3 4 5 6 7 x 8

1 2 7 4 5 6 3 8 x


下面这个版本速度太慢，但是对于STL的学习还是不错的。

//#include <iostream>
//#include <cstdio>
//#include <algorithm>
//#include <list>
//#include <string>
//using namespace std;
//
//const int LEN = 9;
//struct  PStatus
//{
//	string pos;//位置信息
//	int index;//'x'的坐标位置
//	PStatus *parent;//指向父状态
//	char direction;//l,r,u,d
//};
//
//template<class T1,class T2,class T3>
//struct fcmp:public std::binary_function<T1,T2,T3>
//{
//	T3 operator()(T1 first, T2 second) const
//	{
//		return first->pos == second->pos;
//	}
//};
//
//PStatus bStatus;
//PStatus gStatus = {"12345678x"};
//list<PStatus*> open,closed;
//
//bool isInClosed(PStatus* status)
//{
//	list<PStatus*>::iterator it = find_if(closed.begin(),closed.end(),
//		bind2nd(fcmp<PStatus*, PStatus*,bool>(), status));
//	if (it != closed.end())return true;
//	return false;
//}
//
//bool isInOpen(PStatus* status)
//{
//	list<PStatus*>::iterator it = find_if(open.begin(),open.end(),
//		bind2nd(fcmp<PStatus*, PStatus*,bool>(), status));
//	if (it != open.end())return true;
//	return false;
//}
//
//void bfs()
//{
//	PStatus *ps,*np;
//	int i;
//	open.push_back(&bStatus);
//	while (open.size() > 0)
//	{
//		ps = open.front();
//		if (ps->pos == gStatus.pos)//找到答案
//		{
//			while(ps != NULL)
//			{
//				cout<<ps->direction;
//				ps = ps->parent;
//			}
//			return;
//		}		
//
//		open.pop_front();
//		closed.push_back(ps);
//
//		for (i = 0; i < 4; ++i)
//		{
//			switch(i)
//			{
//			case 0://left
//				if (ps->direction != 'r' && ps->index%3 != 0)
//				{
//					np = new PStatus;
//					np->pos = ps->pos;
//					swap(np->pos[ps->index], np->pos[ps->index-1]);
//					if (!isInClosed(np) && !isInOpen(np))
//					{
//						np->parent = ps;
//						np->index = ps->index - 1;
//						np->direction = 'l';
//
//						open.push_back(np);
//					}
//					else
//						delete np;					
//				}
//				break;
//			case 1://right
//				if (ps->direction != 'l' && ps->index%3 != 2)
//				{
//					np = new PStatus;
//					np->pos = ps->pos;
//					swap(np->pos[ps->index], np->pos[ps->index+1]);
//					if (!isInClosed(np) && !isInOpen(np))
//					{
//						np->parent = ps;
//						np->index = ps->index+1;
//						np->direction = 'r';
//
//						open.push_back(np);
//					}
//					else
//						delete np;	
//				}
//				break;
//			case 2://up
//				if (ps->direction != 'd' && (ps->index - ps->index%3) > 2)
//				{
//					np = new PStatus;
//					np->pos = ps->pos;
//					swap(np->pos[ps->index], np->pos[ps->index-3]);
//					if (!isInClosed(np) && !isInOpen(np))
//					{
//						np->parent = ps;
//						np->index = ps->index - 3;
//						np->direction = 'u';
//
//						open.push_back(np);
//					}
//					else
//						delete np;	
//				}
//				break;
//			case 3://down
//				if (ps->direction != 'u' && ps->index  < 6)
//				{
//					np = new PStatus;
//					np->pos = ps->pos;
//					swap(np->pos[ps->index], np->pos[ps->index+3]);
//					if (!isInClosed(np) && !isInOpen(np))
//					{
//						np->parent = ps;
//						np->index = ps->index +3;
//						np->direction = 'd';
//
//						open.push_back(np);
//					}
//					else
//						delete np;	
//				}
//				break;
//			}
//		}		
//	}
//
//	cout<<"unsolvable"<<endl;
//}
//
//bool solvable(string pos,int index)
//{
//	pos.erase(index,1);
//	int sum = 0;
//	for (int i = 1; i < pos.size(); ++i)
//	{
//		for (int j = 0; j < i; ++j)
//			if (pos[i] < pos[j])
//				sum += 1;		
//	}
//	if (sum%2 == 0)return true;
//	else return false;
//}
//
//int main()
//{
//	freopen("in.txt","r",stdin);
//	char ch;
//	for (int i = 0; i < LEN; ++i)
//	{
//		cin>>ch;
//		bStatus.pos += ch;
//		if (ch == 'x')bStatus.index = i;		
//	}		
//
//	if(!solvable(bStatus.pos,bStatus.index))
//		cout<<"unsolvable"<<endl;
//	else
//	{
//		bStatus.parent = NULL;
//		bStatus.direction = 'z';//没有方向
//		bfs();
//	}
//
//}


pku acm 1009
xudacheng06的专栏
08-23 1613
-）常规解法，Time Limit Exceeded 设一个点x与周围8个点相减后绝对值的最大值为edv值。 思想： 1）同一行中的相邻点x1,x2，如果x1已经求得它周围的8个点那么对于x2而言只需要计算另外3个点就可以了。    边界情况就是：对于左边界的点必须求周围8个点
pku acm 1010
xudacheng06的专栏
10-08 1041
参考了http://blog.csdn.net/huxin2007/article/details/6766074的文章。 类似于究举法。 主要思路： 1. 先对输入按面值的从小到大排序，这对剪枝有帮助，比如：     输入面值：1，2，3，4，5        顾客
用 A* 解决八数码问题
hazqfp的专栏
02-27 977
#include 8 s% W2 b- F3 j$ Y4 o #include 3 _  h, ^$ P9 ?/ ? #include using namespace std; 9 S+ n& Q  g  R4 y #define HEAP_PARENT(i)                        (i >> 1); n- q# z9 x0 {. O
pku acm 1077（双向宽度优先解法及HashTable优化算法）
xudacheng06的专栏
09-22 1220
原文来自：http://hi.baidu.com/gropefor/home 的博客中，代码写的非常精巧，强烈推荐。在第二版的优化中使用了HashTable来加速查询。这两个代码使我了解了两种算法，一种是双向宽度优先搜索，另一种就是实际的HashTable的应用，以前一直听说Ha
PKU-1077 Eight (八数码之A*算法)
gk1988的专栏
05-18 558
原题链接 http://poj.org/problem?id=1077 Eight Description The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it.  It is constructed with 15 sliding
pku 1077 Eight 经典8数码问题 单向BFS + A* BFS + 双向BFS
笑风生
12-12 2611
本题的判重的状态的保存用到了全排列的变进制hash方法. 详细的解释见: http://www.cppblog.com/longzxr/archive/2009/08/04/92151.html   下面是我三个版本的算法实现 分别为:     单向BFS     A* BFS     双向BFS 对于本题, 效率递增.     一. 下面是单向BFS算法的实现 目前我的
pku 1077 Eight【八数码、广搜、hash判重】
Beyyes
07-26 1156
pku 1077 Eight（八数码） （广搜+hash判重） /*memcpy(&t,s,sizeof(s))&t: 目标; s: 源 ; sizeof(s): 源内存出复制出的大小 作用:                               由s所指内存区域复制sizeof(s)个字节到t所指内存区域*/ /*memcmp(st[u],st[s],sizeof(st[
pku acm 1833
weixin_30363509的博客
06-05 79
提交了N次，还是TLE。郁闷~~ 事实证明要选C++ 无语 #include <stdio.h> #include <stdlib.h> inline void swap(int *a, int i, int j) { int temp; temp = a[j]; a[j] = a[i]; a[i] = temp;...
pku acm 3278源码
落枫的专栏
09-09 921
#include #include using namespace std; int n,k; const int N=100001; int Q[N]; int visited[N]; int ans[N]; int bfs(int x) { if (x>=k) return (x-k); visited[x]=1; Q[0]=x; int
pku acm 2251源码
落枫的专栏
09-09 901
#include #include using namespace std; const int N=31; char maze[N][N][N]; int visited[N][N][N]; int dir[6][3]={{1,0,0},{0,-1,0},{-1,0,0},{0,1,0},{0,0,-1},{0,0,1}}; int R,C,L; struct N
ACM.rar_PKU_acm pku_pku 1709 crossword_pku acm_visual c
09-14
标签部分进一步细化了内容："pku acm_pku"再次强调这是北京大学ACM竞赛的资料，"pku__1709__crossword"可能是特定的题目标签，而"pku_acm"可能是北京大学ACM团队的标识。"visual_c"可能表示这些代码是使用C++语言，...
acm_pku_code.zip_Code p_acm pku_acm pku pu_acm.pku_pku acm
09-23
"p_acm"、"pku_acm"以及"pu_acm.pku_pku"等标签可能是用于分类或标识这些代码属于北京大学(Peking University, PKU)的ACM训练题目。"acm"一词重复出现，进一步强调了这是关于ACM编程竞赛的内容。 描述中提到"acmer...
PKU-ACM.rar_PKU_acm 题目
09-21
"PKU-ACM.rar"这个压缩包包含了北大ACM题目的一些核心知识点，旨在帮助参赛者理解和掌握算法竞赛中的生命周期题目解法。本文将深入探讨这些经典解法，以及如何运用到实际问题中。 首先，"vc_sx.chm"文件可能是...
pku_ACM.rar_PKU_PKU_ACM
09-20
《北京大学PKU ACM竞赛题目解析》 北京大学(Peking University, 简称PKU)作为中国顶级学府，其在计算机科学领域的教育和竞赛有着深厚的底蕴。ACM（International Collegiate Programming Contest，国际大学生程序...
PKU+ACM.rar_ACM_PKU_acm pku_acm 北大_site:www.pudn.com
09-21
"PKU+ACM.rar"这个压缩包显然包含了与北大ACM竞赛相关的资料，为初学者提供了宝贵的教育资源。以下将详细解析这些资源，并提供学习建议。 首先，"www.pudn.com.txt"可能是从PUDN（普渡大学电子网络）网站下载的资料...
pku acm 1006
xudacheng06的专栏
08-21 944
常规解法（AC）： #include #include #include using namespace std; const int PCYCLES = 23; const int ECYCLES = 28; const int ICYCLES = 33; con
pku acm 1068
xudacheng06的专栏
08-24 844
//括号匹配问题 #include #include using namespace std; int pseq[22];//接收输入p-sequence int harr[22];//辅助数组，统计pseq[i-1]和pseq[i]之间还有多少个'('没有匹配 int w
pku+acm+1011
xudacheng06的专栏
10-14 828
搜索类的题目，参考自：http://hi.baidu.com/alpc29_33/blog/item/43205f10c41dc377ca80c488.html 纠结了N天的一道题。 #include #include #include #include using namespace std; int parts[65]; int used[65]; int num_par
pku acm 1018
xudacheng06的专栏
09-05 770
题目： http://poj.org/problem?id=1018 解题报告： 1）方式一（对应maxbp） 分为两个集合S和S1： 1：初始情况下S[ (65535, 0) ], S1 [ ]为空       输入第一批数据后：（100 25）（ 150
PKU ACM 题目分类大全
"该资源是关于北京大学(PKU) ACM竞赛题目分类的详细列表，包含了各种算法和问题类型的代表性题目。这些题目涵盖了高精度计算、图像处理、动态规划、搜索算法、模拟法、数论、贪心策略以及组合数学等多个领域。每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值