Java 确定数独游戏是否有唯一的解决方案

我正在努力用回溯算法来确定一个数独游戏是有唯一的解决方案，还是有多个解决方案。以下是我使用的回溯代码：

    static boolean solve(int i, int j, int[][] cells) {
    if (i == 9) {
        i = 0;
        if (++j == 9)
            return true;
    }
    if (cells[i][j] != 0)  // skip filled cells
        return solve(i+1,j,cells);

    for (int val = 1; val <= 9; ++val) {
        if (legal(i,j,val,cells)) {
            cells[i][j] = val;
            if (solve(i+1,j,cells))
                return true;
        }
    }
    cells[i][j] = 0; // reset on backtrack
    return false;
}

静态布尔解算（int i、int j、int[][]单元格）{
如果（i==9）{
i=0；
如果（++j==9）
返回true；
}
如果（单元格[i][j]！=0）//跳过填充的单元格
返回解算（i+1，j，单元格）；
for（int val=1；val重置必须在for循环内，并且在
if solve
条件之后

 for (int val = 1; val <= 9; ++val) {
        if (legal(i,j,val,cells)) {
            cells[i][j] = val;
            if (solve(i+1,j,cells))
                return true;
            cells[i][j] = 0; // reset on backtrack
        }
    }

for（int val=1；val如果返回一个数字而不是布尔值，则可以区分存在0、1或多个解决方案的情况

//根据找到的是0、1还是多个解决方案，返回0、1或多个1
静态字节解算（int i、int j、int[][]单元格，字节计数/*初始使用0*/）调用）{
如果（i==9）{
i=0；
如果（++j==9）
返回1+计数；
}
如果（单元格[i][j]！=0）//跳过填充的单元格
返回解算（i+1，j，单元格，计数）；
//搜索2个解决方案，而不是1个
//如果找到两种解决方案，则中断
对于（int val=1；val为什么要使用byte？你最多需要127个解决方案？另外，一个aik
byte
占用的内存与
int
相同，所以实际上没有什么区别。@kajacx:只需要找到两个解决方案就可以了，如果这个解决方案是唯一的，那为什么不呢？但是我看不到任何地方会检查解决方案的数量，所以如果数独可以ld有256个解决方案，那么您的方法将返回0。@kajacx：查看for循环中的条件。您认为我正在为所有解决方案执行DFS吗？@kajacx:BTW:如果没有填充任何字段，即使是int也会溢出，因为有超过
（9！）^3>2^55个
解决方案（应该可以在一条对角线上独立填充3x3字段）。谢谢，现在即使for循环倒计时而不是倒计时，算法也会终止。两个答案都是正确的，不幸的是，我只能接受一个。@user3158988谢谢，由您投票选择正确的答案：）我只想知道为什么有人对我的答案投了反对票。但我们希望他/她能发表评论“legal（）”是什么意思？我正在尝试将此代码翻译成C。如果在位置I、j允许val，则返回true；如果相应的行、列或3x3网格中存在相同的值，则返回false
 for (int val = 1; val <= 9; ++val) {
        if (legal(i,j,val,cells)) {
            cells[i][j] = val;
            if (solve(i+1,j,cells))
                return true;
            cells[i][j] = 0; // reset on backtrack
        }
    }

// returns 0, 1 or more than 1 depending on whether 0, 1 or more than 1 solutions are found
static byte solve(int i, int j, int[][] cells, byte count /*initailly called with 0*/) {
    if (i == 9) {
        i = 0;
        if (++j == 9)
            return 1+count;
    }
    if (cells[i][j] != 0)  // skip filled cells
        return solve(i+1,j,cells, count);
    // search for 2 solutions instead of 1
    // break, if 2 solutions are found
    for (int val = 1; val <= 9 && count < 2; ++val) {
        if (legal(i,j,val,cells)) {
            cells[i][j] = val;
            // add additional solutions
            count = solve(i+1,j,cells, count));
        }
    }
    cells[i][j] = 0; // reset on backtrack
    return count;
}