数独求解算法（回溯法和唯一解法）java实现

最新推荐文章于 2024-10-26 12:24:30 发布
最新推荐文章于 2024-10-26 12:24:30 发布
阅读量1.4w 收藏 31
点赞数 8
分类专栏： 算法 文章标签： 数独 java 回溯法 唯一解法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyiaoyou/article/details/52491187
版权
数独（すうどく，Sudoku）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。

    注：数独的各种知识和解决思路请 参考http://www.llang.net/sudoku/



一、DFS深度填数检测+回溯法

 参考：blog.csdn.net/hll174/article/details/51090461

     1、先把有数字的地方设置标记位为true

     2、 循环遍历数组中没有标记位true的地方，也就是需要填数的地方，如果当前为0，即a[i][j]==0，判断当前所在的九宫格，然后从

          数字1-9依次检测是否在行、列、宫中唯一满足唯一的话，则吧数字赋值给a[i][j]=l+1;然后继续深度遍历为true的话就返回true,否

          则回溯a[i][j]==0等，不满足满足唯一则判断下一个数字，直到1-9都判断不满足则返回false,会回溯到上一层如果当前没有0，说

         明都已经填满且符合唯一条件，则返回true;结束

    代码：

<pre name="code" class="java">import java.util.Scanner;

public class Shudu {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNextInt()) {
			int[][] a = new int[9][9];
			boolean[][] cols = new boolean[9][9];
			boolean[][] rows = new boolean[9][9];
			boolean[][] blocks = new boolean[9][9];// 九大宫的九个数字

			for (int i = 0; i < a.length; i++) {
				for (int j = 0; j < a.length; j++) {
					a[i][j] = sc.nextInt();
					if (a[i][j] != 0) {
						int k = i / 3 * 3 + j / 3;// 划分九宫格,这里以行优先，自己也可以列优先
						int val = a[i][j] - 1;
						rows[i][val] = true;
						cols[j][val] = true;
						blocks[k][val] = true;
					}
				}
			}// 数据装载完毕
			DFS(a, cols, rows, blocks);
			for (int i = 0; i < 9; i++) {
				for (int j = 0; j < 8; j++) {
					System.out.print(a[i][j] + " ");
				}
				System.out.println(a[i][8]);
			}
		}
	}

	public static boolean DFS(int[][] a, boolean[][] cols, boolean[][] rows,
			boolean[][] blocks) {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (a[i][j] == 0) {
					int k = i / 3 * 3 + j / 3;
					for (int l = 0; l < 9; l++) {
						if (!cols[j][l] && !rows[i][l] && !blocks[k][l]) {// l对于的数字l+1没有在行列块中出现
							rows[i][l] = cols[j][l] = blocks[k][l] = true;
							a[i][j] = 1 + l;// 下标加1
							if (DFS(a, cols, rows, blocks))
								return true;// 递进则返回true
							rows[i][l] = cols[j][l] = blocks[k][l] = false;// 递进失败则回溯
							a[i][j] = 0;
						}
					}
					return false;// a[i][j]==0时，l发现都不能填进去
				}// the end of a[i][j]==0
			}
		}
		return true;// 没有a[i][j]==0,则返回true
	}

}



 

 

二、唯一解法
 

1、 显性唯一解法
 

 如果某行已填数字的单元格达到8个,那么该行剩余单元格能填的数字就只剩下那个还没出现过的数字；同理， 如果某列已填数字的单元格达到8个,那么该列剩余单元格能填的数字就只剩下那个还没出现过的数字；如果某九宫格已填数字的单元格达到8个,那么该九宫格剩余单元格能填的数字就只剩下那个还没出现过的数字。
 

2、 隐性唯一解法
 

顾名思义，隐式唯一候选数法也是唯一候选数法的一种，但它不如显式唯一候选数法那样显而易见。
     由于1-9这9个数字要在每行、每列和每个九宫格内至少出现一次，所以如果某个数字在某行、某列或是某个九宫格内所有单元格的候选数列表中只出现一次，那么这个数字就应该填入它出现的那个单元格内，并且从该格所在行、所在列和所在九宫格内其它单元格的候选数列表中删除该数字。 
 

 

解题思路：
 

1、用排除法求取每个值为0的空格所有可能的候选数；
 

2、用隐性唯一解法查看是否有值为0的空格是的值可以确定；
 

3、在1，2过程中当某空格是的值可以确定后则将该值从该格所在行、所在列和所在九宫格内其它单元格的候选数列表中删除该数字；
 

4、若某空格的候选数发生变动时，应查看候选数是只在一个，以及对与该格所在行、所在列和所在九宫格内其它单元格的候选数集的影响；
 

 

代码：
 

 

package paichufa;

public class Shudu {

	int[][] sudo = new int[9][9]; // 保存数独数组
	int[][][] may = new int[9][9][9];// may[i][j][k]保存sudo[i][j]可能的候选数，sudo[i][j]已确定时may[i][j][k]=0

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

	private void Way() {

		// 显式解
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (sudo[i][j] == 0) {
					this.paichu(i, j);
					// System.out.println();

					if (may[i][j][1] == 0) {
						sudo[i][j] = may[i][j][0];
						may[i][j][0] = 0;
						this.delete(i, j, sudo[i][j]);
					}

				}// End if(sudo[i]==0)
			}

		}

		// 隐式解

		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (sudo[i][j] == 0) {
					boolean influ=this.bijiao(i, j);
					// System.out.println();
                    if (influ) {  //当获得某一元素的解后对非同行，同列，同九宫的元素的候选数均有影响
						i=0;
						j=0;
					}
				
				}// End if(sudo[i]==0)
			}

		}

	}// End A

	/**
	 * 
	 * @Description: 
	 *               填充may[i][j][k]，并遍历与sudo[i][j]同行，同列，同九宫元素，获取sudo[i][j]可能的候选数，填充到may
	 *               [i][j]中
	 * @param @param i
	 * @param @param j
	 * @return void
	 * @throws
	 * @date 2016年9月9日
	 */

	//初始化各空格候选数
	private void paichu(int i, int j) {
		if (may[i][j][0] == 0) {
			for (int k = 1; k < 10; k++) {
				may[i][j][k] = k;
			}
		}

		for (int m = i / 3 * 3; m < i / 3 * 3 + 3; m++) {// 同九宫遍历
			for (int n = i / 3 * 3; n < i / 3 * 3 + 3; n++) {
				if (sudo[m][n] != 0 && m != i && n != j) {
					int r = 0;
					while (may[i][j][r] != 0) {
						if (may[i][j][r] == sudo[m][n]) {
							may[i][j][r] = 0;
							for (int k = r; k < 8; k++) {
								int temp = may[i][j][k];
								may[i][j][k] = may[i][j][k + 1];
								may[i][j][k + 1] = temp;
							}
						}
						r++;
					}
				}
			}
		}

		// 同行遍历
		for (int n = 0; n < 9; n++) {
			if (sudo[i][n] != 0 && n != j) {
				int r = 0;
				while (may[i][j][r] != 0) {
					if (may[i][j][r] == sudo[i][n]) {
						may[i][j][r] = 0;
						for (int k = r; k < 8; k++) {
							int temp = may[i][j][k];
							may[i][j][k] = may[i][j][k + 1];
							may[i][j][k + 1] = temp;
						}
					}
					r++;
				}
			}
		}

		// 同列遍历
		for (int m = 0; m < 9; m++) {
			if (sudo[m][j] != 0 && m != i) {
				int r = 0;
				while (may[i][j][r] != 0) {
					if (may[i][j][r] == sudo[m][j]) {
						may[i][j][r] = 0;
						for (int k = r; k < 8; k++) {
							int temp = may[i][j][k];
							may[i][j][k] = may[i][j][k + 1];
							may[i][j][k + 1] = temp;
						}
					}
					r++;
				}
			}
		}

	}

	/**
	 * 
	 * @Description: 当sudo[i][j]确定时，遍历与sudo[i][j]同行，同列，同九宫各元素的候选数 若包含在其中，则从该候选数集中删除，
	 *               并且在删除后候选数集中仅剩唯一解，则可以确定其解，然后以该元素的行，列，解值为参数进行递归调用；
	 * @param @param i
	 * @param @param j
	 * @param @param del 要从各候选数集中删除的值
	 * @return void
	 * @throws
	 * @author 刘林立
	 * @date 2016年9月9日
	 */

	private void delete(int i, int j, int del) {

		// 同九宫遍历
		for (int m = i / 3 * 3; m < i / 3 * 3 + 3; m++) {
			for (int n = i / 3 * 3; n < i / 3 * 3 + 3; n++) {
				if (may[m][n][0] != 0 && m != i && n != j) {

					for (int r = 0; r < 8 && may[m][n][r] != 0; r++) {
						if (may[m][n][r] == del) {

							may[m][n][r] = 0;
							while (r < 8 && may[m][n][r] < may[m][n][r + 1]) {
								int temp = may[m][n][r];
								may[m][n][r] = may[m][n][r + 1];
								may[m][n][r + 1] = temp;
								r++;
							}

							if (may[m][n][1] == 0) {
								sudo[m][n] = may[m][n][0];
								may[m][n][0] = 0;
								this.delete(m, n, sudo[m][n]);

							}
						}
					}
				}
			}
		}

		// 同行遍历
		for (int n = 0; n < 9; n++) {
			if (may[i][n][del - 1] != 0 && n != j) {

				for (int r = 0; r < 8 && may[i][n][r] != 0; r++) {
					if (may[i][n][r] == del) {

						may[i][n][r] = 0;
						while (r < 8 && may[i][n][r] < may[i][n][r + 1]) {
							int temp = may[i][n][r];
							may[i][n][r] = may[i][n][r + 1];
							may[i][n][r + 1] = temp;
							r++;
						}

						if (may[i][n][1] == 0) {
							sudo[i][n] = may[i][n][0];
							may[i][n][0] = 0;
							this.delete(i, n, sudo[i][n]);

						}
					}
				}
			}
		}

		// 同列遍历
		for (int m = 0; m < 9; m++) {
			if (may[m][j][del - 1] != 0 && m != i) {

				for (int r = 0; r < 8 && may[m][j][r] != 0; r++) {
					if (may[m][j][r] == del) {

						may[m][j][r] = 0;
						while (r < 8 && may[m][j][r] < may[m][j][r + 1]) {
							int temp = may[m][j][r];
							may[m][j][r] = may[m][j][r + 1];
							may[m][j][r + 1] = temp;
							r++;
						}

						if (may[m][j][1] == 0) {
							sudo[m][j] = may[m][j][0];
							may[m][j][0] = 0;
							this.delete(m, j, sudo[m][j]);

						}
					}
				}
			}
		}

	}

	/**
	 * 
	 * @Description:将may[i][j]中的所有元素（候选数）依次和与sudo[i][j]同行，同列，同九宫各元素的候选数相比较（在比较时，若sudo[i][j]=0，候选数集不能为空）,若某一元素为该候选数集独有，则该元素即为sudo[i][j]的解；
	 * 
	 * @param @param i
	 * @param @param j
	 * @param @return
	 * @return boolean
	 * @throws
	 * @author 刘林立
	 * @date 2016年9月9日
	 */
	private boolean bijiao(int i, int j) {
		int k = 0;
		int bijiao = may[i][j][k];
		boolean find = true;

		while (may[i][j][k] != 0 && k < 9) {

			// 同九宫遍历
			for (int m = i / 3 * 3; m < i / 3 * 3 + 3 && find; m++) {
				for (int n = i / 3 * 3; n < i / 3 * 3 + 3 && find; n++) {
					if (may[m][n][0] != 0 && m != i && n != j) {
						for (int r = 0; r < 8 && may[m][n][r] != 0 && find; r++) {
							if (may[m][n][r] == bijiao) {
								find = false;
							}
						}
					}
				}
			}

			if (find) {
				break;
			}

			// 同行遍历
			for (int n = 0; n < 9 && find; n++) {
				if (may[i][n][0] != 0 && n != j) {
					for (int r = 0; r < 8 && may[i][n][r] != 0 && find; r++) {
						if (may[i][n][r] == bijiao) {
							find = false;
						}
					}
				}
			}

			if (find) {
				break;
			}

			// 同列遍历
			for (int m = 0; m < 9 && find; m++) {
				if (may[m][j][0] != 0 && m != i) {
					for (int r = 0; r < 8 && may[m][j][r] != 0 && find; r++) {
						if (may[m][j][r] == bijiao) {
							find = false;
						}
					}
				}
			}

			if (find) {
				break;
			}

			k++;
		}

		if (find && may[i][j][k] != 0 && k < 9) {
			sudo[i][j] = may[i][j][k];
			may[i][j][k] = 0;
			this.delete(i, j, sudo[i][j]);

		}

		return find;
	}

}

 

 

 

 


                

        

    

  


    

      

        

            

              
                
                  lllini
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
java数独算法_数独求解算法（回溯法和唯一解法）java实现

				
			

			

				

					weixin_35918198的博客
				

				

					02-12
					
					1240
					
				

			

		

		

			
				
数独(すうどく，Sudoku)是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。注：数独的各种知识和解决思路请 参考http://www.llang.net/sudoku/一、DFS深度填数检测+回溯法参考：blog.csdn.net/hll174/article/details/5109...

			
		

	



                

            
              



	

		

			

				
					
数独游戏的回溯法求解

				
			

			

				

					09-22
				

			

		

		

			
				
Java实现的回溯法解数独，学习递归和回溯法必备，绝对原创，本人慵懒，没有做界面，只有命令行。
导入eclipse运行

			
		

	



              


  
              

                


	

		

			

				
					
JAVA写的数独，附带生成唯一解和各种难度的算法

				
			

			

				

					04-04
				

			

		

		

			
				
自己用GUI写的一个数独小游戏。。可选择难度，生成一个只有唯一解的数独。。可显示答案，玩家也可以自己做题。代码+算法全在里面

			
		

	





	

		

			

				
					
Sudoku-game: 构建包含生成器与求解器的数独系统

					
最新发布

				
			

			

				

					weixin_35414260的博客
				

				

					10-26
					
					711
					
				

			

		

		

			
				
本文还有配套的精品资源，点击获取
 
 


 简介：数独是一款基于逻辑的数字填充游戏，要求在9x9格子中填入数字，满足每行、每列及九个3x3宫格内数字1至9不重复。Sudoku-game项目旨在创建一个完整的数独游戏系统，包括生成器和求解器。生成器负责创建具有唯一解的数独谜题，而求解器则找出给定初始条件下所有可能的解决方案。该项目使用C++编程语言，涉及到多种算法设计、数据结构、用户界...

			
		

	



		

			
		



	

		

			

				
					
java实现数独的算法

				
			

			

				

					weixin_30896825的博客
				

				

					08-23
					
					155
					
				

			

		

		

			
				
数独的历史：  　　数独前身为“九宫格”，最早起源于中国。数千年前，我们的祖先就发明了洛书，其特点较之现在的数独更为复杂，要求纵向、横向、斜向上的三个数字之和等于15，而非简单的九个数字不能重复。儒家典籍《易经》中的“九宫图”也源于此，故称“洛书九宫图”。而“九宫”之名也因《易经》在中华文化发展史上的重要地位而保存、沿用至今。     　　1783年，瑞士数学家莱昂哈德·欧拉发明了一种当时称作“拉...

			
		

	





	

		

			

				
					
回溯法解数独题

				
			

			

				

					
				

				

					11-25
					
					536
					
				

			

		

		

			
				
此题和回溯法走迷宫使用的是同一种算法。回溯法解数独题。数独用二维数组存储。首先根据行、列、小块把那些能直接求出的数字求出来，然后在求不出来的方块中用回溯法。比如从（0，0）到（8，8）找，找到（0，2）位置上的数字还没有求出来，它可能的数字有2、4、5，我们先把（0，2，2）（位置和数字）入栈，然后推出其他的，如果出现矛盾就回溯（也就是出栈），如果退到（0，2）这个位置就要用4、5

			
		

	





	

		

			

				
					
回溯法解数独

				
			

			

				

					Rocketng的博客
				

				

					11-29
					
					315
					
				

			

		

		

			
				
编写一个程序，通过已填充的空格来解决数独问题。
一个数独的解法需遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
空白格用 ‘.’ 表示。


一个数独。
c++回溯法
class Solution {
public:
    void solveSudoku(vector<vecto...

			
		

	





	

		

			

				
					
算法基础（Java）--回溯算法

				
			

			

				

					米奇罗
				

				

					09-01
					
					428
					
				

			

		

		

			
				
前言
本文还是转载加编写，关于算法的教程网上很多很多，找到这个比较适用的，算法本身就是一种思想，掌握了思想，再根据一些数学知识解决问题。
1. 什么是回溯算法？
回溯法是一种系统搜索问题解空间的方法。为了实现回溯，需要给问题定义一个解空间。
说到底它是一种搜索算法。只是这里的搜索是在一个叫做解空间的地方搜索。
而往往所谓的dfs，bfs都是在图或者树这种数据结构上的搜索。
根据定义来看，要实现回溯...

			
		

	





	

		

			

				
					
C++源码实现数独求解算法详解

				
			

			

				

					
				

			

		

		

			
				
数独求解算法的复杂度可以从相对简单的递归回溯到更高效的启发式方法，如深度优先搜索、广度优先搜索、A*搜索算法等。这些算法的效率直接影响到求解的速度，对于一个标准的9x9数独问题，有效的算法可以在几秒钟内...

			
		

	





	

		

			

				
					
sudoku:java中的并行数独求解器

				
			

			

				

					06-11
				

			

		

		

			
				
在Java中实现数独求解器，常见的方法是回溯法。这种方法通过递归尝试填入数字，如果发现违反规则则回退至上一步，直至找到正确答案。而在“sudoku-master”项目中，采用了并行化策略，通过多线程并行处理部分单元格...

			
		

	





	

		

			

				
					
数独(java)

				
			

			

				

					12-23
				

			

		

		

			
				
自己做的一个java数独小程序,希望可以帮助新手联手

			
		

	





	

		

			

				
					
java 数独游戏

				
			

			

				

					08-30
				

			

		

		

			
				
这是本人到目前为止做的最完善的一个程序，也是本人 的一个课程设计，希望大家给点建议。谢谢了。要注意的是，要运行本程序需要安装  JDK 6.0 以上版本。

			
		

	





	

		

			

				
					
Java数独游戏

				
			

			

				

					12-28
				

			

		

		

			
				
Java数独游戏                                                   
好玩。

			
		

	





	

		

			

				
					
回溯法解决数独问题

				
			

			

				

					04-21
				

			

		

		

			
				
命令行输入源文件与结果输出文件，空位置输入为0

			
		

	





	

		

			

				
					
java 数独算法_[Java] 数独生成和求解

				
			

			

				

					weixin_35182280的博客
				

				

					02-12
					
					2321
					
				

			

		

		

			
				
思路1.生成数独数独的生成总体思路是挖洞法。首先在二维数组第一行随机填充1-9 9个数字，然后将这9个数字随机分布到整个二维数组中，然后使用求解数独的算法对此时的数组进行求解，得到一个完整的数独，然后按照用户输入的提示数量进行随机挖洞，得到最终的数独题目。这种方法理论上可以随机生成(81!/72! = 9.5e+16)种不同的数独题目，足够人类玩上几百年了。2.求解数独求解数独使用的是计算机最擅长...

			
		

	





	

		

			

				
					
数独  （java)

				
			

			

				

					qunxingw的专栏
				

				

					11-23
					
					422
					
				

			

		

		

			
				

package qunxingw.com;
 
import java.util.Scanner;
 
public class Soudu {
 
    static int[][] array = new int[9][9];
 
    public void show(int array[][]) {
        for (int i = 0; i &lt; 9; i++) {
 ...

			
		

	





	

		

			

				
					
数独.java

				
			

			

				

					一个初学者 的博客
				

				

					05-28
					
					504
					
				

			

		

		

			
				
package A类有价值的回顾的;import java.util.Scanner;//真的很难下手
//有了一定的套路模型了
public class 数独{
    public static int[][] a = new int[9][9];    public static boolean fa(int h,int l,int i){//检查要求的区域是否有重复，这里不能简单的通过标记T

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值