poj1077

最新推荐文章于 2021-10-30 09:34:58 发布
最新推荐文章于 2021-10-30 09:34:58 发布
阅读量304 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39942341/article/details/89256484
版权

8数码，无解情况为逆序数为奇数，用康托展开压缩成一个int来判重

这个是单组输入

所以我们来一组搜一次

这里给出bfs和A*

A*的话，你可以使用曼哈顿距离，当然，由于不用最少步数，可以用3倍曼哈顿距离加速

IDA*的话，用曼哈顿距离

bfs

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const char direct[4] = { 'u','d','l','r' };
const int dir[4][2] = { {-1,0},{1,0},{0,-1},{0,1} }, N = 362880;
const int aim = 46233;
const int n = 9;
bool visit[N];
char step[N];
int parent[N];
//阶乘
const int fac[n] = { 1,1,2,6,24,120,720,5040,40320 };
//康托展开
int cantor(int s[]) {
	int result = 0, cnt = 0;
	for (int i = 0; i < n - 1; ++i) {
		cnt = 0;
		for (int j = i + 1; j < n; ++j) {
			if (s[i] > s[j])++cnt;
		}
		result += fac[n - 1 - i] * cnt;
	}
	return result;
}
//逆康托展开
void reverseCantor(int hash, int s[], int &space) {
	bool visited[n] = {};
	int temp;
	for (int i = 0; i < n; ++i) {
		temp = hash / fac[n - 1 - i];
		for (int j = 0; j < n; ++j) {
			if (!visited[j]) {
				if (temp == 0) {
					s[i] = j;
					if (j == 0)space = i;
					visited[j] = true;
					break;
				}
				--temp;
			}
		}
		hash %= fac[8 - i];
	}
}
void bfs(int start) {
	queue<int> q;
	q.push(start);
	visit[start] = true;
	parent[start] = -1;
	int state[n], space;
	while (!q.empty()) {
		int preHash = q.front();
		q.pop();
		reverseCantor(preHash, state, space);
		for (int i = 0; i < 4; ++i) {
			int tx = space / 3 + dir[i][0];
			int ty = space % 3 + dir[i][1];
			if (tx < 0 || tx>2 || ty < 0 || ty>2)continue;
			int tz = tx * 3 + ty;
			state[space] = state[tz];
			state[tz] = 0;
			int hash = cantor(state);
			if (!visit[hash]) {
				visit[hash] = true;
				parent[hash] = preHash;
				step[hash] = direct[i];
				if (hash == aim)return;
				q.push(hash);
			}
			state[tz] = state[space];
			state[space] = 0;
		}
	}
}
void printPath() {
	char queue[N];
	int t = 0;
	int c = aim;
	while (parent[c] != -1) {
		queue[t] = step[c];
		++t;
		c = parent[c];
	}
	for (int i = t - 1; i >= 0; --i)printf("%c", queue[i]);
	printf("\n");
}
int main() {
	char x;
	int a[n];
	for (int i = 0; i < n; ++i) {
		scanf(" %c", &x);
		if (x == 'x')a[i] = 0;
		else a[i] = x - '0';
	}
	int hash = cantor(a);
	bfs(hash);
	if (!visit[aim])printf("unsolvable\n");
	else printPath();
	return 0;
}

A*

曼哈顿距离

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
const char direct[4] = { 'u','d','l','r' };
const int dir[4][2] = { {-1,0},{1,0},{0,-1},{0,1} }, N = 362880;
const int aim = 46233;
const int n = 9;
bool visit[N];
int parent[N];
char step[N];
int goal_state[9][2] = {
	{0, 0}, {0, 1}, {0, 2},
	{1, 0}, {1, 1}, {1, 2},
	{2, 0}, {2, 1}, {2, 2}
};
//阶乘
const int fac[n] = { 1,1,2,6,24,120,720,5040,40320 };
//康托展开
int cantor(int s[]) {
	int result = 0, cnt = 0;
	for (int i = 0; i < n - 1; ++i) {
		cnt = 0;
		for (int j = i + 1; j < n; ++j) {
			if (s[i] > s[j])++cnt;
		}
		result += fac[n - 1 - i] * cnt;
	}
	return result;
}
//逆康托展开
void reverseCantor(int hash, int s[], int &space) {
	bool visited[n] = {};
	int temp;
	for (int i = 0; i < n; ++i) {
		temp = hash / fac[n - 1 - i];
		for (int j = 0; j < n; ++j) {
			if (!visited[j]) {
				if (temp == 0) {
					s[i] = j;
					if (j == 0)space = i;
					visited[j] = true;
					break;
				}
				--temp;
			}
		}
		hash %= fac[8 - i];
	}
}
//f=g+h
int g[N];
int h(int s[]) {
	int k, result = 0;
	for (int i = 0; i < 3; ++i) {
		for (int j = 0; j < 3; ++j) {
			k = i * 3 + j;
			if (s[k] == 0)continue;
			result += abs(1.0*(i - goal_state[s[k] - 1][0])) + abs(1.0*(j - goal_state[s[k] - 1][1]));
		}
	}
	return result;
}
void printPath() {
	char queue[31];
	int t = 0;
	int c = aim;
	while (parent[c] != -1) {
		queue[t] = step[c];
		++t;
		c = parent[c];
	}
	for (int i = t - 1; i >= 0; --i)printf("%c", queue[i]);
	printf("\n");
}
class Chess {
public:
	int hash, f;
	Chess(const int &hash, const int &f) :hash(hash), f(f) {}
	bool operator <(const Chess &t)const {
		if (f == t.f)return g[hash] > g[t.hash];
		return f > t.f;
	}
};
//A*算法
void A_star(int start, int f) {
	priority_queue<Chess> q;
	q.push(Chess(start, f));
	int preHash, hash, state[n], space, preH;
	while (!q.empty()) {
		//取出节点
		Chess preChess = q.top();
		preHash = preChess.hash;
		if (preHash == aim) {
			printPath();
			return;
		}
		q.pop();
		preH = preChess.f - g[preHash];
		reverseCantor(preHash, state, space);
		for (int i = 0; i < 4; ++i) {
			int tx = space / 3 + dir[i][0];
			int ty = space % 3 + dir[i][1];
			if (tx < 0 || tx>2 || ty < 0 || ty>2)continue;
			int tz = 3 * tx + ty;
			state[space] = state[tz];
			state[tz] = 0;
			hash = cantor(state);
			//没访问过
			if (!visit[hash]) {
				step[hash] = direct[i];
				g[hash] = g[preHash] + 1;
				visit[hash] = true;
				parent[hash] = preHash;
				q.push(Chess(hash, g[hash] + h(state)));
			}
			//访问过了，但是从preHash走一步到hash比直接走到hash更短
			//else if (g[preHash] + 1 < g[hash]) {
			//	step[hash] = direct[i];
			//	g[hash] = g[preHash] + 1;
			//	parent[hash] = preHash;
			//	q.push(Chess(hash, g[hash] + preH));
			//}
			state[tz] = state[space];
			state[space] = 0;
		}
	}
	printf("unsolvable\n");
}
int getInv(int s[]) {
	int cnt = 0;
	for (int i = 1; i < n; ++i) {
		if (s[i] == 0)continue;
		for (int j = 0; j < i; ++j) {
			if (s[j] == 0)continue;
			if (s[i] < s[j])
				++cnt;
		}
	}
	return cnt & 1;
}
int main() {
	char x;
	int a[n];
	for (int i = 0; i < n; ++i) {
		scanf(" %c", &x);
		if (x == 'x')a[i] = 0;
		else a[i] = x - '0';
	}
	if (getInv(a) == 1) {
		printf("unsolvable\n");
	}
	else {
		int hash = cantor(a);
		visit[hash] = true;
		parent[hash] = -1;
		g[hash] = 0;
		A_star(hash, h(a));
	}
	return 0;
}

IDA*

#include<iostream>
#include<cstdio>
using namespace std;
const char direct[4] = { 'u','d','l','r' };
const int dir[4][2] = { {-1,0},{1,0},{0,-1},{0,1} };
const int n = 9;
bool flag;
int a[n];
char step[32];
int maxDeep;
int goal_state[9][2] = {
	{0, 0}, {0, 1}, {0, 2},
	{1, 0}, {1, 1}, {1, 2},
	{2, 0}, {2, 1}, {2, 2}
};
int abs(int a, int b) {
	if (a > b)return a - b;
	return b - a;
}
int h() {
	int k, result = 0;
	for (int i = 0; i < 3; ++i) {
		for (int j = 0; j < 3; ++j) {
			k = i * 3 + j;
			if (a[k] == 0)continue;
			result += abs(i, goal_state[a[k] - 1][0]) + abs(j, goal_state[a[k] - 1][1]);
		}
	}
	return result;
}
int getInv() {
	int cnt = 0;
	for (int i = 1; i < n; ++i) {
		if (a[i] == 0)continue;
		for (int j = 0; j < i; ++j) {
			if (a[j] == 0)continue;
			if (a[i] < a[j])
				++cnt;
		}
	}
	return cnt & 1;
}
bool reverse(char a, char b) {
	return a == 'u'&& b == 'd'
		|| a == 'd'&& b == 'u'
		|| a == 'l'&& b == 'r'
		|| a == 'r'&&b == 'l';
}
int dfs(int deep, int space) {
	int t = h(), f = deep + t;
	if (f > maxDeep)return f;
	if (t == 0) {
		flag = true;
		return f;
	}
	int nextBound = 32;
	for (int i = 0; i < 4; ++i) {
		if (deep > 0 && reverse(step[deep - 1], direct[i]))continue;
		int tx = space / 3 + dir[i][0];
		int ty = space % 3 + dir[i][1];
		if (tx < 0 || tx>2 || ty < 0 || ty>2)continue;
		int tz = 3 * tx + ty;
		a[space] = a[tz];
		a[tz] = 0;
		step[deep] = direct[i];
		f = dfs(deep + 1, tz);
		if (flag)return f;
		if (f < nextBound)nextBound = f;
		a[tz] = a[space];
		a[space] = 0;
	}
	return nextBound;
}
int main() {
	char x;
	int space;
	for (int i = 0; i < n; ++i) {
		scanf(" %c", &x);
		if (x == 'x') {
			a[i] = 0;
			space = i;
		}
		else a[i] = x - '0';
	}
	if (getInv() == 1) {
		printf("unsolvable\n");
	}
	else {
		maxDeep = h();
		while (true) {
			flag = false;
			maxDeep = dfs(0, space);
			if (flag) {
				step[maxDeep] = '\0';
				printf("%s\n", step);
				break;
			}
		}
	}
	return 0;
}

 

Nightmare004
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
POJ 1077 算法
08-09
关于C++ 算法 北大网站POJ 八数码问题
POJ1077八数码
loveSiri的博客
03-03 1020
POJ1077:八数码问题(Eight) POJ1077查看 文章目录POJ1077:八数码问题(Eight)@[toc]**解题思路**基础知识铺垫广度优先搜索BFS+康托展开广度优先搜索BFS+set二分查找双向广搜DBFS+set二分查找启发式算法+堆+普通标记数组更多策略 解题思路 求步数最少的解时候用广搜 状态的表示问题 若以字符串的形式表示，需要10字节，且检查是否达到目标状...
poj 1077 Eight
zjsru_Beginner的博客
10-30 389
题目： 是一道经典的八数码问题。将一个3×3的矩阵，通过每次和四周的数字进行互换，最终达到目标状态。其中用字母“l”表示相左移动，“u”表示向上，“r”表示向右，“d”表示向下，最后结果，输出移动的字母。 样例： 目标位置是 初始位置是： 为了从初始位置到达目标位置，需要先将x与5换位置，再与6换位置，也就是先...
POJ1077(经典的八数码问题)
飞翔的小鸟
08-05 3667
很经典的八数码问题，可以用单向广度优先搜索、双向广度优先搜索、A*算法、IDA算法解。 用了双向广度优先搜索和A*算法解，在用A*算法时，纠结了好几天，后来在网上看了一份博客才发现自己错在哪。之后解出来了。虽然做这题时很纠结，不过收获真的很大，痛而快乐着………… 下面贴出用双向广度优先搜索和A*算法做的代码   //A*算法 #include #include #include
八数码问题
weixin_47750287的博客
01-31 1690
题目描述 在一个3*3的棋盘上放置编号为1-8的8个方块，每个占一格，另外还有一个空格。与空格相邻的数字方块可以移动到空格里。任务1：指定初始棋局和目标棋局，计算出最少的移动步数；任务2：输出数码的移动序列。 把空格看成0，一共有9个数字。 输入样例： 1 2 3 0 8 4 7 6 5 1 0 3 8 2 4 7 6 5 输出样例: 2 题目分析 这里先解决任务1，任务2是在任务1的基础上通过标记序列和回溯去解决的。 把一个棋局看成一个状态图，总共有9！= 362880个状态。从初始棋局开始，每次移
poj-1077（bfs+康托展开）
weixin_45732455的博客
03-18 293
原题链接http://poj.org/problem?id=1077 大概题意就是把你输入的九宫格变成目标九宫格（大概小时候都玩过这种游戏，复原九宫格），然后输出每次移动的方向。不了解康托展开的可以百度一下，对全排列的判重很有用。提交的时候c++一直超时，改来改去还是不行，改成g++就ac了，郁闷。 代码如下（附有题解） #include<iostream> #include<q...
poj 1077 Eight.md
11-17
poj 1077 Eight.md
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
POJ 1077 八数码 三种解法
lvxin1204的博客
05-31 5058
POJ 1077 Eight题目链接：http://poj.org/problem?id=1077
poj 1077(八数码)
weixin_30517001的博客
04-14 64
八数码问题有多种解法，本题解采用的是双向搜索 View Code 1 #include<iostream> 2 #include<map> 3 #include<string> 4 #include<queue> 5 #include<stdio.h> 6 #include<strin...
poj-1077 八数码 【a*】
a915800048的专栏
08-22 531
状态总数是9! = 362880 种，不算太多，可以满足广搜和A*对于空间的需求。 假如把x看做0。最大为876543210没超过Int的存储范围，所以用一个int值来表示其平面状态。  #include #include #include #include #include #define keyMax 999983 #define target 123456780 using n
poj 1077 八数码
weixin_30399055的博客
03-16 42
1 #include<iostream> 2 #include<queue> 3 #include<algorithm> 4 #include<string> 5 #include<cstring> 6 #include<cstdio> 7 //正向广度搜索 8 //把“x...
POJ 1077 Eight A*算法 八数码问题
mimo9527的专栏
02-26 1400
可以使用A*算法解决。启发函数f(n)=g(n)+h(n)，h(n)=所有棋子到其目标位置的距离和*K，也就是曼哈顿距离*K。经过验证，k=1时会超出POJ的时限，k=4时最快，但K=4得到的结果其实不能最短路径，如下面例子：8 6 7 2 5 4 3 x 1K=1:  ruuldlurddlurrulldrdruldlururddK=2:  urulldrrdluulddruruldldrruldluurrddK=4：ruulddrulldruldrrululddruurddluruldlurrddluu
POJ 1077 Eight A*算法求解
正月看雪花的博客
02-01 3384
题目描述         在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。 在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。 我们的目的是通过交换，使得网格变为如下排列（称为正确排列）： 例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交...
poj 1077 解题报告
李世操的空间
02-27 499
最近学人工智能，要学A*算法，就重新做这道题经典的8数码问题，传说不做这道题人生不完整呢我之前是用的广搜暴力搞的，不过太慢了，还要说说我的hash方法，我是用康托展开来hash的，这个东西是算一个排列在所有排列大小排多少，比如（1,2,3）有6个排列，321是最大的就是第六个。还有就是康托展开的逆运算，就是知道是第几大的，算出这个排列来； 康托展开： long cantor( int s[]
北大 算法基础 八数码 POJ1077
ywqzj的博客
04-02 131
练习代码 : #include<iostream> #include<bitset> using namespace std; int goalStatus;//目标状态 bitset<362880> Flags; const int MAXS = 370000; char result[MAXS];//移动的过程 struct Node { int status;//排列序号 int father;//父序号 char move;//移动到当前序号的动作 N
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nightmare004

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值