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

最新推荐文章于 2024-05-10 12:26:16 发布
最新推荐文章于 2024-05-10 12:26:16 发布
阅读量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
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    8
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    31
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
回溯java算法_聊聊算法——回溯算法

				
			

			

				

					weixin_30111277的博客
				

				

					02-27
					
					968
					
				

			

		

		

			
				
“递归只应天上有，迭代还须在人间”，从这句话我们可以看出递归的精妙，确实厉害，递归是将问题规模逐渐减小，然后再反推回去，但本质上是从最小的规模开始，直到目标值，思想就是数学归纳法，举个例子，求阶乘 N!=(N-1)！*N ，而迭代是数学中的极限思想，利用前次的结果，逐渐靠近目标值，迭代的过程中规模不变，举例如For循环，直到终止条件。递归的思想不复杂，但代码理解就麻烦了，要理解一个斐波那契数组递归...

			
		

	



                

              
                



	

		

			

				
					
数独技巧－唯一解法 

				
			

			

				

					bbxiaofisher的专栏
				

				

					08-15
					
					3453
					
				

			

		

		

			
				
                                    当某行已填数字的宫格达到8个,那么该行剩余宫格能填的数字就只剩下那个还没出现过的数字了。成为行唯一解.            当某列已填数字的宫格达到8个,那么该列剩余宫格能填的数字就只剩下那个还没出现过的数字了。成为列唯一解.            当某九宫格已填数字的宫格达到8个,那么该九宫格剩

			
		

	



                


  
              

                


	

		

			

				
					
输入数独题目，程序输出数独的唯一解。保证所有已知数据的格式都是合法的，并且题目有唯一的解。

				
			

			

				

					AI新手程序员
				

				

					03-23
					
					3861
					
				

			

		

		

			
				
你一定听说过“数独”游戏。如【图1.png】，玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个同色九宫内的数字均含1-9，不重复。数独的答案都是唯一的，所以，多个解也称为无解。本图的数字据说是芬兰数学家花了3个月的时间设计出来的较难的题目。但对会使用计算机编程的你来说，恐怕易如反掌了。本题的要求就是输入数独题目，程序输出数独的唯一解。我们保证所有已知数据的...

			
		

	





	

		

			

				
					
Python基础——循环

					
最新发布

				
			

			

				

					loong_的博客
				

				

					05-10
					
					960
					
				

			

		

		

			
				
详解python 中 while循环、for循环的使用方法

			
		

	



		

			
		



	

		

			

				
					
算法笔记（java）——回溯篇

				
			

			

				

					qq_40460454的博客
				

				

					07-22
					
					1120
					
				

			

		

		

			
				
回溯算法解决问题最有规律性，借用一下卡哥的图：只要遇到上述问题就可以考虑使用回溯，回溯法的效率并不高，是一种暴力解法，其代码是嵌套在for循环中的递归，用来解决暴力算法解决不了的问题，即可以通过回溯控制递归的层数，递归后可以进行回溯操作，这样下一次循环就不会收到上一次的影响。解决回溯问题的关键就在于清楚整个回溯递归过程，毕竟是嵌套在for循环中的递归，最好的办法就是把所有情况画成一个树，这样就比较清晰了。

			
		

	





	

		

			

				
					
剑指 Offer 38. 字符串的排列(回溯)1

				
			

			

				

					秋雨行舟
				

				

					12-10
					
					343
					
				

			

		

		

			
				
输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例:

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

解法一：回溯


class Solution {
    List<String> res = new LinkedList<>();
    char[] c;

    public String[] permutation(String s) {

			
		

	





	

		

			

				
					
回溯算法总结（java）

				
			

			

				

					万物皆可互联，一切均可编程
				

				

					04-15
					
					6327
					
				

			

		

		

			
				
回溯算法
回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。
回溯法的基本行为是搜索，搜索过程使用剪枝函数来为了避免无效的搜索。剪枝函数包括两类：1. 使用约束函数，剪去不满足约束条件的路径；2.使用限界函数，剪去不能得到最优解的路径。
回溯算法说白了就是穷举法。不过回溯算法使用剪枝函数，剪去一

			
		

	





	

		

			

				
					
融合人工求解策略的数独回溯求解法

				
			

			

				

					04-30
				

			

		

		

			
				
数独有唯一解，回溯法可以保证获得正确结果。为了提高回溯法求解效率，向前搜索用最基础的人工策略进行求解，这样只需要两三个正确的候选数就可求解成功。基础人工策略求解的结果分为求解成功、求解失败和求解不确定...

			
		

	





	

		

			

				
					
数独游戏的回溯法求解

				
			

			

				

					09-22
				

			

		

		

			
				
总结来说，本实例通过Java的回溯法实现了数独游戏的求解，深入展示了递归和回溯法在解决复杂问题时的强大能力。理解并掌握这种算法对于提升编程思维和问题解决技巧具有重要意义。在实际应用中，回溯法不仅适用于数独...

			
		

	





	

		

			

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

				
			

			

				

					06-11
				

			

		

		

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

			
		

	





	

		

			

				
					
Java 算法实现代码集.zip

				
			

			

				

					06-17
				

			

		

		

			
				
9. **回溯法**：用于寻找所有可能的解决方案，如八皇后问题、N皇后问题和数独解法。  10. **随机化算法**：如鸽巢原理、鸽巢分箱、Monte Carlo方法等，用于解决难以精确求解的问题，或者提供近似解。  这些算法的...

			
		

	





	

		

			

				
					
数独游戏，随机生成只有唯一解的数独表

				
			

			

				

					11-21
				

			

		

		

			
				
用c#写了一个能够随机生成唯一解的数独游戏，很多其他人的都不是随机生成，而且也不能保证生成的数独表的解是唯一的，所以我自己写了一个可以随机生成唯一解的数独游戏，上传上来和大家一起学习学习，看看算法还有没有什么可以改进的，我的另一篇博文有具体的详解代码思路。

			
		

	





	

		

			

				
					
java数独计算器

				
			

			

				

					12-26
				

			

		

		

			
				
Java数独计算器是一种基于编程语言Java实现的工具，专门用于解决数独问题。它采用了一系列高级算法来高效地找出数独谜题...通过学习和理解这个项目，开发者可以深入掌握回溯法、搜索算法以及如何在Java中实现这些算法。

			
		

	





	

		

			

				
					
java回溯算法_请问~：什么是回溯算法，及在java中如何实现？

				
			

			

				

					weixin_28677451的博客
				

				

					02-16
					
					184
					
				

			

		

		

			
				
/**@(#)EightQueens.java1.02004-02-12**Copyright2004,willwang.Allrightsreserved.*emailfarmworker@163.netfarmworker@163.com.*/importjava.awt.*;importjava.awt.event.*;importjava.apple...

			
		

	





	

		

			

				
					
数独算法-递归与回溯

					
热门推荐

				
			

			

				

					後雪寒的专栏
				

				

					12-07
					
					2万+
					
				

			

		

		

			
				
1.概述数独（Sudoku）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 
1)终盘数量: 
数独中的数字排列千变万化，那么究竟有多少种终盘的数字组合呢？ 
6,670,903,752,021,072,936,960（约为6.67×10的21次方）种组合

			
		

	





	

		

			

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

				
			

			

				

					米奇罗
				

				

					09-01
					
					387
					
				

			

		

		

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

			
		

	





	

		

			

				
					
数独怎么用Java实现，写一下实现的代码

				
			

			

				

					weixin_42576410的博客
				

				

					02-13
					
					536
					
				

			

		

		

			
				
要用Java实现数独，需要先定义一个9x9的二维数组来保存游戏的状态，然后定义一个方法，该方法检查每一行、每一列、每一个3x3的九宫格是否有重复的数字。示例代码如下：public static boolean isValidSudoku(int[][] board) {
  for (int i = 0; i < 9; i++) {
    HashSet rowSet = new Hash...

			
		

	





	

		

			

				
					
Java 编写数独游戏 窗体程序 完整源码

				
			

			

				

					bangxiecode的博客
				

				

					02-17
					
					2518
					
				

			

		

		

			
				
java 编写数独       游戏窗体程序 完整源码游戏，可以直接用来做课程设计或者毕业设计；代码功能完善，下载后可以直接运行！！

			
		

	





	

		

			

				
					
java 编写数独求解算法

				
			

			

				

					06-02
				

			

		

		

			
				
好的，下面是一个简单的 Java 数独求解算法的实现。该算法使用递归和回溯来解决数独问题。

```
public class SudokuSolver {

    private static final int BOARD_SIZE = 9;
    private static final int BOX_SIZE = 3;
    private int[][] board;

    public SudokuSolver(int[][] board) {
        this.board = board;
    }

    public boolean solve() {
        for (int row = 0; row < BOARD_SIZE; row++) {
            for (int col = 0; col < BOARD_SIZE; col++) {
                if (board[row][col] == 0) {
                    for (int num = 1; num <= BOARD_SIZE; num++) {
                        if (isValid(row, col, num)) {
                            board[row][col] = num;
                            if (solve()) {
                                return true;
                            } else {
                                board[row][col] = 0;
                            }
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isValid(int row, int col, int num) {
        // Check row
        for (int i = 0; i < BOARD_SIZE; i++) {
            if (board[row][i] == num) {
                return false;
            }
        }
        // Check column
        for (int i = 0; i < BOARD_SIZE; i++) {
            if (board[i][col] == num) {
                return false;
            }
        }
        // Check box
        int boxRow = row - row % BOX_SIZE;
        int boxCol = col - col % BOX_SIZE;
        for (int i = boxRow; i < boxRow + BOX_SIZE; i++) {
            for (int j = boxCol; j < boxCol + BOX_SIZE; j++) {
                if (board[i][j] == num) {
                    return false;
                }
            }
        }
        return true;
    }

    public void printSolution() {
        for (int row = 0; row < BOARD_SIZE; row++) {
            for (int col = 0; col < BOARD_SIZE; col++) {
                System.out.print(board[row][col] + " ");
            }
            System.out.println();
        }
    }
}
```

如上所示，首先定义了一个 `SudokuSolver` 类，它包含一个二维数组 `board` 作为数独棋盘，并提供了 `solve()` 方法来解决数独问题。

在 `solve()` 方法中，我们使用两个嵌套的循环来遍历整个棋盘，并检查每个单元格是否为空。如果单元格是空的，我们就尝试将 1 到 9 中的每个数字填入该单元格，并检查该数字是否有效。如果该数字有效，则继续递归地调用 `solve()` 方法来解决下一个单元格。如果递归调用返回 true，则表示我们已经找到了一个解，否则我们需要回溯并尝试下一个数字。

在 `isValid()` 方法中，我们检查给定数字是否有效。我们首先检查给定行和列中是否已经存在该数字，然后检查该数字是否在相应的 3x3 方框中出现过。

最后，我们提供了一个 `printSolution()` 方法，用于打印解决方案。

使用该算法，我们可以通过以下方式解决数独问题：

```
int[][] board = {
    {5, 3, 0, 0, 7, 0, 0, 0, 0},
    {6, 0, 0, 1, 9, 5, 0, 0, 0},
    {0, 9, 8, 0, 0, 0, 0, 6, 0},
    {8, 0, 0, 0, 6, 0, 0, 0, 3},
    {4, 0, 0, 8, 0, 3, 0, 0, 1},
    {7, 0, 0, 0, 2, 0, 0, 0, 6},
    {0, 6, 0, 0, 0, 0, 2, 8, 0},
    {0, 0, 0, 4, 1, 9, 0, 0, 5},
    {0, 0, 0, 0, 8, 0, 0, 7, 9}
};
SudokuSolver solver = new SudokuSolver(board);
if (solver.solve()) {
    solver.printSolution();
} else {
    System.out.println("No solution found");
}
```

在解决方案找到后，我们将打印整个棋盘，其中所有空单元格都填有相应的数字。

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值