Java 使用回溯的数独解算器

我最近一直在研究一个回溯数独求解算法，现在我想问一下如何将solve（）方法从void改为boolean

我正在使用一个非常简单的回溯算法，它目前运行良好，但我宁愿使用布尔值而不是空值，因为有一个打印堆栈不是很好

谢谢

public class Backtracking{


 static int backtrack = 0;


 //check if valid in row
protected static boolean validInRow(int row, int value)
{
   for( int col = 0; col < 9; col++ )
     if( board[row][col] == value )
         return false ;

  return true ;
}

  //check if valid in column
protected static boolean validInCol(int col, int value)
{
    for( int row = 0; row < 9; row++ )
     if( board[row][col] == value )
        return false ;

  return true ;
 }

 //check if valid in 3*3
protected static boolean validInBlock(int row, int col, int value)
{
  row = (row / 3) * 3 ;
    col = (col / 3) * 3 ;

   for( int r = 0; r < 3; r++ )
      for( int c = 0; c < 3; c++ )
       if( board[row+r][col+c] == value )
         return false ;

   return true ;
 }




      //call other methods
public void solve(int row, int col) throws Exception
{

   if(row > 8)
     throw new Exception("Solution found") ;
  else
  {

     while(board[row][col] != 0)
     {
        if( ++col > 8 )
        {
           col = 0 ;
           row++ ;


           if( row > 8 )
              throw new Exception( "Solution found" ) ;
        }
     }


     for(int value = 1; value < 10; value++)
     {
        if(validInRow(row,value) && validInCol(col,value) && validInBlock(row,col,value))
        {
           board[row][col] = value;
           new PrintEvent(board);



           if( col < 8 )
              solve(row, col + 1);
           else
              solve(row + 1, 0);

           backtrack++;
         }
      }


      board[row][col] = 0;

      }
   }
 }

公共类回溯{
静态int回溯=0；
//检查行中是否有效
受保护的静态布尔值validInRow（int行，int值）
{
for（int col=0；col<9；col++）
if（线路板[行][列]==值）
返回false；
返回true；
}
//检查在列中是否有效
受保护的静态布尔值validInCol（int-col，int-value）
{
对于（int行=0；行<9；行++）
if（线路板[行][列]==值）
返回false；
返回true；
}
//检查是否在3*3中有效
受保护的静态布尔validInBlock（int行、int列、int值）
{
行=（行/3）*3；
col=（col/3）*3；
对于（int r=0；r<3；r++）
对于（int c＝0；c＜3；C++）
if（线路板[行+r][列+c]==值）
返回false；
返回true；
}
//调用其他方法
公共void solve（int行，int列）引发异常
{
如果（第8行）
抛出新异常（“找到解决方案”）；
其他的
{
while（板[行][列]！=0）
{
如果（++col>8）
{
col=0；
行++；
如果（第8行）
抛出新异常（“找到解决方案”）；
}
}
用于（int值=1；值<10；值++）
{
if（validInRow（行，值）和validInCol（列，值）和validInBlock（行，列，值））
{
板[行][列]=值；
新PrintEvent（董事会）；
if（col<8）
求解（行，列+1）；
其他的
求解（行+1，0）；
回溯++；
}
}
线路板[行][列]=0；
}
}
}

好吧，您可以

捕获

异常以避免堆栈跟踪，但这仍然不是很好。将返回类型更改为

boolean

后，您可以执行以下操作：

       if( col < 8 ) {
          if (solve(row, col + 1)) {
              return true;
          }
       } else {
          if (solve(row + 1, 0)) {
              return true;
          }
       }

if（列<8）{
if（求解（行、列+1））{
返回true；
}
}否则{
if（求解（行+1，0））{
返回true；
}
}

当然，然后将

throw

语句更改为

returntrue
公共布尔解算（int行，int列）引发异常
public boolean solve(int row, int col) throws Exception
{
  {

     while(board[row][col] != 0)
     {
        if( ++col > 8 )
        {
           col = 0 ;
           row++ ;


           if( row > 8 )
             return true
        }
     }


     for(int value = 1; value < 10; value++)
     {
        if(validInRow(row,value) && validInCol(col,value) && validInBlock(row,col,value))
        {
           board[row][col] = value;
           new PrintEvent(board);



           if( col < 8 )
              solve(row, col + 1);
           else
              solve(row + 1, 0);

           backtrack++;
         }
      }


      board[row][col] = 0;

      }
   }
return false;
 }

{
{
while（板[行][列]！=0）
{
如果（++col>8）
{
col=0；
行++；
如果（第8行）
返回真值
}
}
用于（int值=1；值<10；值++）
{
if（validInRow（行，值）和validInCol（列，值）和validInBlock（行，列，值））
{
板[行][列]=值；
新PrintEvent（董事会）；
if（col<8）
求解（行，列+1）；
其他的
求解（行+1，0）；
回溯++；
}
}
线路板[行][列]=0；
}
}
返回false；
}
+1用于尝试捕捉。我曾经做过一些编程竞赛，我使用了try-catch原则进行回溯。这不是一个优雅的黑客，但它非常有用。非常感谢我的朋友，我尝试了很多次改变它，但总是徒劳（好像我把返回语句弄乱了）。我做了你所做的，它就像一个符咒！