算法笔记 问题 C: 【宽搜入门】8数码难题 终于AC啦

最新推荐文章于 2021-11-06 22:02:45 发布
最新推荐文章于 2021-11-06 22:02:45 发布
阅读量262 收藏 1
点赞数
分类专栏： 算法学习 bfs 文章标签： 算法 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47820972/article/details/106458841
版权

题目链接：http://codeup.cn/problem.php?cid=100000609&pid=2

吐槽

这次就是因为太粗心！

文章目录

思路
  • 找最优步骤——BFS
  • 关键是确定每个入队的状态
  • 可用一个string记录每个状态
  • 0的位置从1开始
代码一（内存超限）已解决
//内存超限
#include<iostream>
#include<queue>
#include<map>
using namespace std;


string source = " ";
string target = " ";

struct Node
{
	string s;
	int x0;
	int step;
};

queue<Node> q;
map<string, bool> mp;

bool judge(Node top, int way)
{
	int index = top.x0;
	// cannot to up  1     123
	if (index <= 3 && index >= 1 && way == 1)
		return false;
	// cannot to down  2   789
	if (index <= 9 && index >= 7 && way == 2)
		return false;
	// cannot to left  3  147
	if (index % 3 == 1 && way == 3)
		return false;
	// cannot to right  4  369
	if (index % 3 == 0 && way == 4)
		return false;
	return true;
}

Node doSomething(Node top, int way)
{
	Node newNode = top;
	string s1 = top.s;
	int index = top.x0;
	switch (way)
	{
	case 1:
		swap(s1[index], s1[index - 3]);
		index -= 3;
		break;
	case 2:
		swap(s1[index], s1[index + 3]);
		index += 3;
		break;
	case 3:
		swap(s1[index], s1[index - 1]);
		index--;
		break;
	case 4:
		swap(s1[index], s1[index + 1]);
		index++;
		break;
	}

	newNode.s = s1;
	newNode.step++;
	newNode.x0 = index;
	
	return newNode;

}


int BFS(Node st)
{
	while (!q.empty())
	{
		q.pop();
	}

	q.push(st);
	mp[st.s] = true;
	while (!q.empty())
	{
		Node top = q.front();
		q.pop();
		if (top.s == target)
		{
			return top.step;
		}

		for (int way = 1; way <= 4; way++)
		{
			if (judge(top, way))
			{
				Node newNode = doSomething(top, way);
				if (mp[newNode.s] == false)
				{
					q.push(newNode);
					mp[newNode.s] = true;  // 就是这一行漏掉了！！！
				}		
			}
		}

	}
	return -1;
}


int main()
{
	int tmp[10] = { 0 };
	int index0 = 0;
	for (int i = 1; i <= 9; i++)
	{
		scanf("%d", &tmp[i]);
		source += tmp[i]+'0';
		if (tmp[i] == 0)
			index0 = i;
	}
	for (int i = 1; i <= 9; i++)
	{
		scanf("%d", &tmp[i]);
		target += tmp[i]+'0';
	}

	Node st = { source,index0,1 };
	printf("%d", BFS(st));

	return 0;
}

还不太清楚怎么解决超内存的问题，也许原因出在太多string？

解决！mp[newNode.s] = true; // 就是这一行漏掉了！！！

代码二 第一次修改 (还是内存超限）已解决
  • 把容器string全换成int类型
//内存超限
#include<iostream>
#include<queue>
#include<unordered_map>
using namespace std;


int source = 0;
int target = 0;

struct Node
{
	int s;
	int x0;
	int step;
};

queue<Node> q;
unordered_map<int, bool> mp;

bool judge(Node top, int way)
{
	int index = top.x0;
	// cannot to up  1     123
	if (index <= 3 && index >= 1 && way == 1)
		return false;
	// cannot to down  2   789
	if (index <= 9 && index >= 7 && way == 2)
		return false;
	// cannot to left  3  147
	if (index % 3 == 1 && way == 3)
		return false;
	// cannot to right  4  369
	if (index % 3 == 0 && way == 4)
		return false;
	return true;
}


int exchange(int num,int index1, int index2)
{
	// 整数是整数，不会影响0的index
	//int flag = num / 1e8;  // 012345678  结果就是0
	//char a[10] = { '0' };
	//if (flag != 0) // 123456780
	//{
	//	int p = 1e8;
	//	int temp = num;
	//	for (int i = 1; i <= 9; i++)
	//	{
	//		a[i] = temp / p + '0';
	//		temp = temp % p;
	//		p /= 10;
	//	}
	//}
	//else
	//{
	//	int p = 1e7;
	//	int temp = num;
	//	for (int i = 2; i <= 9; i++)
	//	{
	//		a[i] = temp / p + '0';
	//		temp = temp % p;
	//		p /= 10;
	//	}
	//}
	//swap(a[index1], a[index2]);

	//int sum = atoi(a);
	//return sum;

	int num2 = num;
	char cur[10];
	sprintf(cur, "%09d", num2);
	swap(cur[index1 - 1], cur[index2 - 1]);
	sscanf(cur, "%d", &num2);
	return num2;

}



Node doSomething(Node top, int way)
{
	Node newNode = top;
	int s1 = top.s;
	int index = top.x0;
	switch (way)
	{
	case 1:
		s1 = exchange(s1, index, index - 3);
		index -= 3;
		break;
	case 2:
		s1 = exchange(s1, index, index + 3);
		index += 3;
		break;
	case 3:
		s1 = exchange(s1, index, index - 1);
		index--;
		break;
	case 4:
		s1 = exchange(s1, index, index + 1);
		index++;
		break;
	}

	newNode.s = s1;
	newNode.step++;
	newNode.x0 = index;

	return newNode;

}


int BFS(Node st)
{
	while (!q.empty())
	{
		q.pop();
	}

	q.push(st);
	mp[st.s] = true;
	while (!q.empty())
	{
		Node top = q.front();
		q.pop();
		if (top.s == target)
		{
			return top.step;
		}

		for (int way = 1; way <= 4; way++)
		{
			if (judge(top, way))
			{
				Node newNode = doSomething(top, way);
				if (mp[newNode.s] == false)
				{
				    q.push(newNode);
				    mp[newNode.s] =true;  // 就是这一行！！！
				}
			}
		}

	}
	return -1;
}


int main()
{
	int tmp[10] = { 0 };
	int index0 = 0;
	for (int i = 1; i <= 9; i++)
	{
		scanf("%d", &tmp[i]);
		source = source*10 + tmp[i];
		if (tmp[i] == 0)
			index0 = i;
	}
	for (int i = 1; i <= 9; i++)
	{
		scanf("%d", &tmp[i]);
		target = target * 10 + tmp[i];
	}

	Node st = { source,index0,1 };
	printf("%d", BFS(st));

	return 0;
}
代码三 第二次修改（终于AC）
  • 采用数组模拟队列，代码略微修改了一番
  • 兜兜转转学习了新的点sscanf和sprintf
#include<iostream>
#include<queue>
#include<unordered_map>
using namespace std;


int source = 0;
int target = 0;
const int maxn = 400000;
struct Node
{
	int s;
	int x0;
	int step;
}q[maxn];

//queue<Node> q;

unordered_map<int, bool> mp;

bool judge(Node top, int way)
{
	int index = top.x0;
	// cannot to up  1     123
	if (index <= 3 && index >= 1 && way == 1)
		return false;
	// cannot to down  2   789
	if (index <= 9 && index >= 7 && way == 2)
		return false;
	// cannot to left  3  147
	if (index % 3 == 1 && way == 3)
		return false;
	// cannot to right  4  369
	if (index % 3 == 0 && way == 4)
		return false;
	return true;
}


int exchange(int num, int index1, int index2)
{
	// 整数是整数，不会影响0的index
	//int flag = num / 1e8;  // 012345678  结果就是0
	//char a[10] = { '0' };
	//if (flag != 0) // 123456780
	//{
	//	int p = 1e8;
	//	int temp = num;
	//	for (int i = 1; i <= 9; i++)
	//	{
	//		a[i] = temp / p + '0';
	//		temp = temp % p;
	//		p /= 10;
	//	}
	//}
	//else
	//{
	//	int p = 1e7;
	//	int temp = num;
	//	for (int i = 2; i <= 9; i++)
	//	{
	//		a[i] = temp / p + '0';
	//		temp = temp % p;
	//		p /= 10;
	//	}
	//}
	//swap(a[index1], a[index2]);

	//int sum = atoi(a);
	//return sum;

	int num2 = num;
	char cur[10];
	sprintf_s(cur, "%09d", num2);
	swap(cur[index1 - 1], cur[index2 - 1]);
	sscanf_s(cur, "%d", &num2);
	return num2;

}



Node doSomething(Node top, int way)
{
	Node newNode = top;
	int s1 = top.s;
	int index = top.x0;
	switch (way)
	{
	case 1:
		s1 = exchange(s1, index, index - 3);
		index -= 3;
		break;
	case 2:
		s1 = exchange(s1, index, index + 3);
		index += 3;
		break;
	case 3:
		s1 = exchange(s1, index, index - 1);
		index--;
		break;
	case 4:
		s1 = exchange(s1, index, index + 1);
		index++;
		break;
	}

	newNode.s = s1;
	newNode.step++;
	newNode.x0 = index;

	return newNode;

}

int head = 0, tail = 1;
int BFS(Node st)
{
	memset(q, 0, sizeof(q));
	q[head] = st;
	mp[st.s] = true;
	while (head!=tail)
	{
		Node top = q[head];
		if (top.s == target)
		{
			return top.step;  // 开始就是1了
		}

		for (int way = 1; way <= 4; way++)
		{
			if (judge(top, way))
			{
				Node newNode = doSomething(top, way);
				if (mp[newNode.s] == false)
				{
					mp[newNode.s] = true;
					q[tail++] = newNode;
				}
					
			}
		}
		head++;

	}
	return -1;
}


int main()
{
	int tmp[10] = { 0 };
	int index0 = 0;
	for (int i = 1; i <= 9; i++)
	{
		scanf_s("%d", &tmp[i]);
		source = source * 10 + tmp[i];
		if (tmp[i] == 0)
			index0 = i;
	}
	for (int i = 1; i <= 9; i++)
	{
		scanf_s("%d", &tmp[i]);
		target = target * 10 + tmp[i];
	}

	Node st = { source,index0,1 };
	printf("%d", BFS(st));

	return 0;
}
大神代码

参考
https://blog.csdn.net/u012283461/article/details/79078653

  • 注意点：同一层使用的是同一个cur
  • swap(cur, pos, swapTo);//一个新状态处理完了一定要记得将交换的0交换回来
inkuu
关注
专栏目录
问题 C: 【宽搜入门】8数码难题
说......的博客
03-21 321
题目描述 初始状态的步数就算1，哈哈 输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 注： 题目意思是，8个数加一个空位（0），每一步可以让周围的数（上下左右）走到这个空位里来，问初始矩阵最少要走几步才能变成结...
【算法笔记第8.2节-BFS 】问题 C: 【宽搜入门】8数码难题
xunalove的博客
03-13 406
题目描述 初始状态的步数就算1，哈哈 输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 这个题目没有把条件说清楚，完整题目描述： 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。...
Codeup 问题 C: 【宽搜入门】8数码难题
qq_38768005的博客
08-16 381
题目描述 初始状态的步数就算1，哈哈 输入：第一个33的矩阵是原始状态，第二个33的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 这个题的描述简单到坑人，0代表得是空得意思，然后每次移动是指将空格上下左右任意一个块移动到空格处。 这个题目我乍一看是时理解错了，我在写判重代码时，用的思...
BFS——《算法笔记》8.2小节 问题 C: 【宽搜入门】8数码难题
weirdo_coder的博客
04-10 534
问题 C: 【宽搜入门】8数码难题 时间限制:20 Sec内存限制:128 MB 提交:176解决:60 [提交][状态][讨论版][命题人:外部导入] 题目描述 初始状态的步数就算1，哈哈 输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4...
入门笔记+题集:SOSdp
qq_35577488的博客
03-12 3391
1.介绍: 原文链接 1.1.SOSdp(Sum over subsets dpSum \ over \ subsets\ dpSum over subsets dp)顾名思义，子集和dp。用来维护子集信息的。俗称高维前缀和. 1.2.最常见的形式：求解dp(mask)=∑i∈maskaidp(mask)=\sum_{i \in mask}a_idp(mask)=∑i∈mask​ai​ 注意：i∈mask等价于i&mask=i等价于i∣ma
终极算法：机器学习和人工智能如何重塑世界
热门推荐
GitChat
04-12 1万+
内容简介 算法已在多大程度上影响我们的生活？购物网站用算法来为你推荐商品，点评网站用算法来帮你选择餐馆，GPS 系统用算法来帮你选择好的路线，公司用算法来选择求职者……当机器最终学会如何学习时，将会发生什么？ 不同于传统算法，现在悄然主导我们生活的是“能够学习的机器”，它们通过学习我们琐碎的数据，来执行任务；它们甚至在我们还没提出要求，就能完成我们想做的事。 什么是终极算法？ 机器学习五大学派，每...
2021-11-06 动画讲编程笔记-准备算法面试的经验分享
qq_44745905的博客
11-06 1212
@R星校长 面对算法面试有五点注意： 1.明确目标与规划 2.精选题目初步练 3.每题三遍成习惯 4.纸和白板刻意练 5.善用教程与视频 在刷题前一定要先明确目标并做好规划，我们的目标是为了找工作准备算法面试，还是为了巩固，学习算法知识，又或者是为了参加程序设计竞赛，目标的不同会直接影响规划与训练，如果是为了找工作，那么就要针对面试算法的考点精心准备，不能随意的选择题目，对于很多面试中几乎不会涉及的算法（扩展KMP）（计算几何）或者是比较偏冷门题目，做这些题会消耗很多时间和精力。 对于新人，不常考的算法题.
【算法基础总结】算法基础 (算法竞赛，面试...)
Skyed_blue的博客
03-16 2715
算法基础 ​ （By: Skyed_blue 转载注明作者) 文章目录算法基础前言dfs(深度优先遍历)bfs(广度优先遍历)二分查找(二分枚举)并查集位运算双指针栈(stack)字典树(trie)前缀和初等数论贪心动态规划(dp)结语 前言 本篇为算法基础整合，主要偏向于对基础算法的总结和整理。本篇将会介绍个人刷算法题的一些经验，基础算法的简要描述，基础算...
Fabric 1.0源代码分析(46)ECDSA（椭圆曲线数字签名算法）
尹成的技术博客
05-21 3094
# Fabric 1.0源代码笔记 之 ECDSA（椭圆曲线数字签名算法）## 1、椭圆曲线算法概述### 1.1、无穷远点、无穷远直线、射影平面* 平行线相交于无穷远点；* 直线上有且只有一个无穷远点；* 一组相互平行的直线有公共的无穷远点；* 平面上任何相交的两直线，有不同的无穷远点；* 全部无穷远点沟通一条无穷远直线；* 平面上全部无穷远点和全部普通点构成射影平面。### 1.2、射影平面点...
八数码问题
08-07
z1. 综合应用“深度优先搜索”、“宽度优先搜索”、“启发式搜索”这三种人工智能搜索技术的基本知识以及程序设计的相关知识。 z2. 通过设计一个八数码问题求解程序，学习、了解状态空间搜索的思想，进一步加深对人工智能课程相关启发式搜索的理解。 z实验内容 1. 针对八数码问题，在Windows环境下用C/C++语言(Java语言)实现几种搜索算法(最好是图形界面)： y深度优先搜索 P23 y宽度优先搜索 P24 y启发式搜索算法（h1(n) =W(n) “不在位”的将牌数）P28 y启发式搜索算法（h2(n) = P(n)将牌“不在位”的距离和）P40 y启发式搜索算法（h3(n) = h(n)＝P(n)+3S(n)） P46 2. 随机产生或手动输入初始状态，对于同一个初始状态，分别用上面的5种方法进行求解，并对比结果
【宽搜】Vijos P1360 八数码问题
PHILIP0917的博客
03-24 192
题目链接： 　　https://vijos.org/p/1360 题目大意： 　　3x3格子上放1~8数字，一个空位，每次空位可与上下左右交换，固定终止布局，求输入的起始布局需要几步到达终止布局 题目思路： 　　【搜索】 　　一眼题BFS，宽搜即可，判重我比较暴力直接把状态记下，没hash、cantor什么的。 1 // 2 //by coolxxx ...
codeup【宽搜入门】8数码难题——BFS
Syy
03-02 294
初始状态的步数就算1，哈哈 输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 注意：题目中 0的位置是可以移动的空格。 分析：首先题目要求求最少的步数，很容易想到使用BFS ; 那么对于BFS,我们要解决的主要问题是要确定每一步的状态并保...
codeup|问题 C: 【宽搜入门】8数码难题
weixin_43340821的博客
03-23 109
题目描述 初始状态的步数就算1，哈哈 输入：第一个33的矩阵是原始状态，第二个33的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 代码 #include<iostream> #include<queue> using namespace std; struct node { int x, y; int step; int M[3][3]; int l
Codeup100000609问题 C: 【宽搜入门】8数码难题
Lerbronjames的博客
08-05 148
题目描述： 初始状态的步数就算1，哈哈 输入： 第一个33的矩阵是原始状态，第二个33的矩阵是目标状态。 输出： 移动所用最少的步数 Input： 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output： 6 提示： 此题直接用全排列散列会造成数组过大，因此采用康托展开来求解 康托展开 实现代码1： #include <cstdio> #include <cstdlib> #include <ctime> #include <cst
八数码
bggl的博客
07-29 523
题目描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入 输入初试状态，一行九个数字，空格用0表示 输出 只有一行，该行只有一个数字，...
【宽搜】wikioi 1225 八数码难题
wakawaka
09-08 706
题目大意： 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入： 初始状态。 输出： 达到目标状态需要的步数。 分析： 宽搜+哈希
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值