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;
}

static boolean legal(int i, int j, int val, int[][] cells) {
    for (int k = 0; k < 9; ++k)  // row
        if (val == cells[k][j])
            return false;

    for (int k = 0; k < 9; ++k) // col
        if (val == cells[i][k])
            return false;

    int boxRowOffset = (i / 3)*3;
    int boxColOffset = (j / 3)*3;
    for (int k = 0; k < 3; ++k) // box
        for (int m = 0; m < 3; ++m)
            if (val == cells[boxRowOffset+k][boxColOffset+m])
                return false;

    return true; // no violations, so it's legal
}

静态布尔解算（int i、int j、int[][]单元格）{
如果（i==9）{
i=0；
如果（++j==9）
返回true；
}
如果（单元格[i][j]！=0）//跳过填充的单元格
返回解算（i+1，j，单元格）；
对于（int val=1；val它尝试当前合法的每个插入。

当然，只有其中一个会得到真正的解决方案，因此它会检查它们是否正确

不正确的尝试会在某个地方进入死胡同并返回false。
该算法使用递归和回溯进行工作，基本上它会“强制”数独，直到找到正确答案

它将在数字1-9之间循环，直到找到一个此时对该单元格合法的数字。当数字组合无效时，算法将回溯（即重置数字）。它将执行每一列和每一行，直到解决整个难题。
通俗地说，
solve
执行以下操作：

solve(position, field):
  for all values of all positions:
    fill current position of field with current value
    solve(neighboring position, field) # solve 'the rest'
    if field is a legal solution:
      return field
    else:
      unfill current position of field
    # the loop proceeds to next position

谢谢你指出这一点，我知道我的意思，但写得很糟糕：）我会更新你会发现非常有趣的内容-即使它是错误的语言：）