LeetCode——解数独

最新推荐文章于 2022-01-09 21:42:58 发布
最新推荐文章于 2022-01-09 21:42:58 发布
阅读量656 收藏
点赞数
分类专栏： DFS 动态规划 优先队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yanpr919/article/details/97795234
版权
动态规划 同时被 3 个专栏收录
20 篇文章 0 订阅
订阅专栏
DFS
9 篇文章 0 订阅
订阅专栏
优先队列
8 篇文章 0 订阅
订阅专栏

Note:

  • 给定的数独序列只包含数字 1-9 和字符 '.' 。
  • 你可以假设给定的数独只有唯一解。
  • 给定数独永远是 9x9 形式的。

 在看到题目的第一个思路是通过深度优先搜索+优先队列+动态规划的方法解决

        根据三条规则找出每个空位可能的取值数量，通过优先队列选出可能数量最少的一个点进行填充，紧接着对优先队列进行更新，重新判断改变加入点后每个点不同的取值可能，接着按照DFS的思想对每个点进行依次填充，期间对于已经搜寻过的局势进行标记，再次出现时不进行搜索，直到所有点均被填充即为解。（要注意在DFS时全局变量的应用要格外小心！！！）

        最后做出的结果正确，但是执行时间及内存消耗都较大。下附提交结果图及程序代码：

  •  
  • class Solution {
public:
	struct Pos {
		int x, y;	//坐标
		//int depth;	//深度
	};
	struct Class {
		Pos pos;	//坐标
		int num;	//可能存在值的数量
		bool possible[9] = { 0 };	//可能存在的值,0代表可取

		bool operator <(const Class& s)const
		{
			if (num == s.num)	//可能性数量相同时按照坐标排序
			{
				if (pos.x == s.pos.x)
					return pos.x > s.pos.x;		//
				else
					return pos.y > s.pos.y;		//
			}
			else
				return num > s.num;		//最小堆
		}
	};
	struct DT {
		int arry[9][9];
	};
	map<string, int>DT_Flag;	//动态规划标志位，对每一种情况都有唯一的二维数组标识
	map<int, DT>Source;		//表示应放回优先队列的深度及情况
	//priority_queue<Class> Home;	//定义填写顺序
	
	int Gong[3][3][9] = { 0 };		//表征每个3×3宫里已经填写的数（1代表填写）
	bool Finish = 0;
	int High;

	bool Updata(int h, priority_queue<Class> &updata)	//更新优先队列
	{
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j++)
			{
				if (Source[h].arry[i][j] == 0)
				{
					Class D;
					D.pos.x = i;
					D.pos.y = j;
					D.num = 9;
					for (int k = 0; k < 9; k++)
					{
						if (Source[h].arry[i][k] != 0)
						{
							if (D.possible[Source[h].arry[i][k] - 1] == 0)
							{
								D.possible[Source[h].arry[i][k] - 1] = 1;	//同行存在，改为不可取
								D.num = D.num - 1;
								//cout << i << "  " << j << ' ' << Source[h][i][k] << ' '<< D.possible[Source[h][i][k] -1]<<endl;
							}
						}
					}
					for (int k = 0; k < 9; k++)
					{
						if (Source[h].arry[k][j] != 0)
						{
							if (D.possible[Source[h].arry[k][j] - 1] == 0)
							{
								D.possible[Source[h].arry[k][j] - 1] = 1;	//同列存在，改为不可取
								D.num = D.num - 1;
								//cout << i << "  " << j << ' ' << Source[h][k][j] << ' ' << D.possible[Source[h][k][j] - 1] << endl;
							}
						}
					}
					int off_x = i / 3;
					int off_y = j / 3;
					for (int k = 0; k < 3; k++)
					{
						for (int p = 0; p < 3; p++)
						{
							if (Source[h].arry[k + off_x*3][p + off_y*3] != 0)	//同宫存在，改为不可取
							{
								if (D.possible[Source[h].arry[k + off_x * 3][p + off_y * 3] - 1] == 0)
								{
									D.possible[Source[h].arry[k + off_x * 3][p + off_y * 3] - 1] = 1;
									D.num = D.num - 1;
									//cout << i << "  " << j << ' ' << Source[h][k + off_x * 3][p + off_y * 3] << ' ' << D.possible[Source[h][k + off_x * 3][p + off_y * 3] - 1] << endl;
								}
							}
						}
					}
					if (D.num == 0)		//有空但无值可取
						return 0;		//代表该状态不可解
					updata.push(D);
				}
			}
		}
		return 1;
	}	

	void DFS(int high)
	{
		priority_queue<Class> Home;
		if (!Updata(high, Home))
			return;
		if (Home.empty())
		{
			High = high;
			Finish = 1;
		}
		if (!Finish)
		{
			Class Save = Home.top();
			for (int i = 0; i < Save.num; i++)
			{
				int j = 0;
				while (Save.possible[j] == 1)
				{
					j++;
				}
				Save.possible[j] = 1;
				//cout << "x=" << Save.pos.x << " y=" << Save.pos.y << " num = " << Save.num << " value = " << j + 1 << endl;
				Source[0].arry[Save.pos.x][Save.pos.y] = j + 1;
				
				string dt;
				for (int k = 0; k < 9; k++)
				{
					for (int p = 0; p < 9; p++)
					{
						char s[5] ;
						sprintf_s(s, "%d", Source[0].arry[k][p]);
						dt = dt.append(s);
						//cout << "zifu = " << dt << endl;
					}
				}
				
				if (DT_Flag.find(dt) == DT_Flag.end())	//如果未检测该情况，则检测
				{
					DT_Flag[dt] = 1;
					DFS(0);
				}

				if (!Finish)
					Source[0].arry[Save.pos.x][Save.pos.y] = 0;
				else
					return;
			}
		}
	}

    由于前期思路问题，优先队列其实没有必要，每次简单判断可能性即可。

  • 通过看网上大佬们的解题思路，发现自己在规则判定上效率很低，我的规则判断在每个点上，而大佬的判断在行、列、宫上，这样更加简单。

  • 经过改进后时间有显著减少

  • 结果图及程序代码如下：

lass Solution {
public:
	struct Class {
		int x,y;	//坐标
		int num;	//可能存在值的数量
		bool possible[9] = { 0 };	//可能存在的值,0代表可取
	};

	map<string, int>DT_Flag;	//动态规划标志位，对每一种情况都有唯一的二维数组标识
	int Source[9][9];		//表示应放回优先队列的深度及情况

	bool row[9][9] = { 0 };		//行填写数组
	bool col[9][9] = { 0 };		//列填写数组
	bool Gong[3][3][9] = { 0 };		//表征每个3×3宫里已经填写的数（1代表填写）

	bool Finish = 0;
	int release = 0;
	bool Updata(Class &Min)	//更新优先队列
	{
		Min.num = 10;
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j++)
			{
				Class CC;
				if (Source[i][j] == 0)
				{
					release++;
					CC.x = i;
					CC.y = j;
					CC.num = 9;
					for (int k = 0; k < 9; k++)
					{
						if (row[i][k] != 0 || col[j][k] != 0 || Gong[i / 3][j / 3][k] != 0)
						{
							CC.possible[k] = 1;	//同行、列、宫存在，改为不可取
							CC.num = CC.num - 1;
							//cout << i << "  " << j << ' ' << k + 1 << ' '<<endl;
						}
					}
					if (CC.num == 0)		//有空但无值可取
					{
						Min = CC;
						return 0;		//代表该状态不可解
					}
					else if (CC.num == 1)
					{
						Min = CC;
						return 1;
					}
					else if (CC.num < Min.num)
						Min = CC;
				}
			}
		}
		if (Min.num == 10)
		{
			release = 0;
			//cout << "end" << endl;
		}
		return 1;
	}	
	
	void DFS()
	{
		Class Min;
		if (!Updata(Min))
			return;
		if (release == 0)
		{
			Finish = 1;
		}
		if (!Finish)
		{
			for (int i = 0; i < Min.num; i++)
			{
				int j = 0;
				while (Min.possible[j] == 1)
				{
					j++;
				}
				Min.possible[j] = 1;
				//cout << "x=" << save.x << " y=" << save.y << " num = " << save.num << " value = " << j + 1 << endl;
				Source[Min.x][Min.y] = j + 1;
				row[Min.x][Source[Min.x][Min.y] - 1] = 1;		//更新
				col[Min.y][Source[Min.x][Min.y] - 1] = 1;
				Gong[Min.x / 3][Min.y / 3][Source[Min.x][Min.y] - 1] = 1;

				string dt;
				for (int k = 0; k < 9; k++)
				{
					for (int p = 0; p < 9; p++)
					{
						char s[5] ;
						sprintf(s, "%d", Source[k][p]);
						dt = dt.append(s);
					}
				}
				//cout << "zifu = " << dt << endl;
				
				if (DT_Flag.find(dt) == DT_Flag.end())	//如果未检测该情况，则检测
				{
					DT_Flag[dt] = 1;
					DFS();
				}

				if (!Finish)
				{
					Source[Min.x][Min.y] = 0;
					row[Min.x][j] = 0;		//更新
					col[Min.y][j] = 0;
					Gong[Min.x / 3][Min.y / 3][j] = 0;
				}
				else
					return;
			}
		}
	}

	void solveSudoku(vector<vector<char>>& board) {
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j++)
			{
				if(board[i][j] == '.')
					Source[i][j] = 0;
				else
				{
					Source[i][j] = board[i][j] - '0';
					row[i][Source[i][j] - 1] = 1;
					col[j][Source[i][j] - 1] = 1;
					Gong[i / 3][j / 3][Source[i][j] - 1] = 1;
				}
			}
		}
		DFS();
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j++)
			{

				board[i][j] = Source[i][j] + '0';
			}
		}
	}
};

 

颜值博主
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python解标准数独
qq_43653510的博客
12-18 327
首先谈下数独的结构，9*9一共81个数格。标准数独要求每一行，每一列，每一宫格之内填入1-9 9个数字而不重复。其开始状态的给定数字最低为17个，根据难度降低，给定数字依次增加。 0、准备工作：本次数独算法设计的数据结构为列表+集合，一个列表中加入9个小列表，每个小列表中加入9个集合。填入给定的数字，其他空格全部填入{0-9}可能的数字，经过后面的算法，逐个消除，直到81个数格长度全部为1 lis...
Leetcode每日一题——7. 解数独
weixin_52709752的博客
02-27 717
Leetcode每日一题——7. 解数独。递归四部曲。回溯
LeetCode回溯专题-37. 解数独
m0_51630248的博客
01-09 252
37. 解数独 编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用'.'表示。 方法一:暴力搜索，三个used数组储存每行每列每个九宫格的数字使用状态，然后再根据used数组来回溯 class Solution { public void solveSudoku(...
Codewars 打怪日记 5星级kyu 数独游戏 我是否完成了数组 Did I Finish my Sudoku? 看小菜和大神循环的巧妙运用
Cinderella_hou的博客
06-27 1529
史蒂夫·乔布斯说过，每个人都应该学习给电脑编写程序的技术，因为这一过程能够教你如何去思考！学习编程的渠道有很多种，比如你可以利用一些互动平台或者书籍去学习编程，无论是哪种，只要找到适合自己的就OK。编程极富有创造性，你可以创造出许多新奇有趣的想法。很多时候，开发者在相同的问题上花费了大量时间，而忽略了创造性。所以很多网站都发起编程挑战赛，找到千千万的实现方法，codewars就是这样一个在线编程社
【LeetCode 37】解数独（递归回溯法）
SAMCYC的博客
05-19 757
题目 编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9 形式的。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/sudoku-s
leetcode&mdash;&mdash;-解数独(回溯法)
01-20
如： 方法：回溯法： 回溯法的思想就是：对于一个问题有多个选择方式，先选择一个方式执行下去，若在执行过程中，发现不符合规则，则回退，回到选择方式的步骤，进而选择其他方式，继续试。 重要：对于回溯法，一定...
LeetCode&mdash;&mdash;两数之和
01-20
一.个人探索 二.网上优秀编程 三....一....1.暴力解法 答题思路：两个循环来遍历列表中的所有组合可能来获取答案值。...优点：简单易懂，比较容易想到的一种嵌套循环进行遍历的思想。...缺点：使用嵌套循环遍历整个数据，耗费...
Sologala#LeetCode#解数独1
07-25
[37]解数独|sudoku-solverDFS 搜索即可重点在于 可以使用的判断 ，这里建立三种bitset<9> 来作为某个位置是否能够选用这个数字的凭据。
LeetCode&mdash;&mdash;移除元素
12-22
答题思路：先判断数组中有无指定元素，若没有则直接返回该数组，若有则进行个数的统计，之后运用remove函数的特点逐一进行删除 具体程序如下： class Solution: def removeElement(self, nums: List[int], val:
LeetCode&mdash;&mdash;001 Two Sum
01-07
Description Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not ...
软件工程基础个人项目——数独终局生成和求解
Hamabe的博客
12-27 389
软件工程基础个人项目——数独终局生成和求解GitHub项目地址项目任务描述耗费时间估计解题思路描述功能建模生成终局算法行内轮换行间轮换求解终局算法设计实现主要函数程序分析与改进应用代码质量分析工具消除警告应用代码性能分析工具提高程序性能1.代码复用2.输出改进运行代码性能探查器进行CPU查询实际耗费时间 GitHub项目地址 DropLee/Sudoku 项目任务描述 实现一个命令行程序，程序能：...
android中常用的finish()与onDestroy()的区别
热门推荐
三石的专栏
02-14 2万+
大家好，2016新的一年，一切都是新的开始。学习也不能怠慢。刚刚get到新知识，以前只是一知半解，解释不清楚。这次算是彻底明白了。 finish()方法： 用于结束一个Activity的生命周期，而onDestory()方法则是Activity的一个生命周期。其作用是在一个Activity对象被销毁之前，Android系统会调用该方法，用于释放此Activity之前所占用的资源。finish会调
NOIP模拟题 2016.11.12 [Catalan数] [贪心] [动态规划] [DLX] [数独]
C'est la vie.
11-12 899
T1： 题意：有2N个数，排成两列，要求每一列中的数递增，并且同一位置右边的数比左边的大。ans(1…4)=1,2,5,14很明显的Catlan数。。 怎么推出来的我也不知道。 F[n] = F[n-1] * (4n-2) / (n+1)，预处理逆元。#include<iostream> #include<cstdio> #include<cstring> #include<cstdlib>
leetcode 37. 解数独(Sudoku Solver)
一叶之修的博客
08-30 229
编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 '.' 。 你可以假设给定的数独只有唯一解...
Leetcode 37解数独 c++
qq_43387999的博客
01-20 639
思路：写两个子函数，一个是检测在9*9的宫格中添加一个数后，是否该宫格为有效的数独。另一个函数是给空格中的空白处添加数字，并利用第一个函数检测添加后是否为有效的数独。 class Solution { public: void solveSudoku(vector&lt;vector&lt;char&gt;&gt;&amp; board) { solvesudokuDFS(...
LeetCode 37. 解数独
I am a slow walker, but I never walk backwards!
07-09 743
题目描述 解题思路 暴力递归 使用dfs进行暴力递归，需要判断一下三个条件，标记一下是否出现过，行、列以及3*3的小格子中是否出现过。 注意递归结束的条件，失败后不要返回(在这里写错了，没注意到)。 代码实现 int r[12][12]; int c[12][12]; int g[12][12]; int mp[12][12]; class Solution { pu...
Leetcode 37. 解数独
Bendaai的博客
04-26 459
暴力可过class Solution { public: bool hang[9][9] = {}, lie[9][9] = {}, ge[9][9] = {}; bool solve(vector<vector<char>>& board) { for (int i = 0; i<9; ++i) for (int j = 0; j < 9; ++
LeetCode题目：解数独
weixin_39224015的博客
05-02 130
题目描述： 编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数...
数独（c++ dfs实现）
人生若只能如初见的博客
01-29 2567
数独概念，思路，解法思路，C++code 该博客整体代码的思路十分的清晰，值得借鉴！ 上述博客当中的代码dfs知识输出的一种数组的答案，如果该数独有多中解法的话，只需将dfs的代码简单改动即可（如下）： void dfs(int row,int col) { if (row>9) //如果行超出9行，直接输出 { for (int i=1; i9; i+
leetcode 2 两数相加
最新发布
09-24
根据提供的引用内容，Leetcode 2 "两数相加"是一个涉及链表的问题。该问题给定了两个非负整数，每个整数的每一位都是按照逆序的方式存储在链表中。我们需要将这两个链表相加，并返回一个新的链表作为结果。 具体...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值