feat: add weekly contest 465 (#4680)

Author: yanglbme

solution/0000-0099/0037.Sudoku Solver/README.md

@@ -68,11 +68,9 @@ tags:
 
 ### 方法一：回溯
 
-我们用数组 `row`、`col`、`box` 分别记录每一行、每一列、每个 3x3 宫格中数字是否出现过。如果数字 `i` 在第 `r` 行、第 `c` 列、第 `b` 个 3x3 宫格中出现过，那么 `row[r][i]`、`col[c][i]`、`box[b][i]` 都为 `true`。
+我们用数组 $\textit{row}$, $\textit{col}$, $\textit{box}$ 分别记录每一行、每一列、每个 3x3 宫格中数字是否出现过。如果数字 $i$ 在第 $r$ 行、第 $c$ 列、第 $b$ 个 3x3 宫格中出现过，那么 $\text{row[r][i]}$, $\text{col[c][i]}$, $\text{box[b][i]}$ 都为 $true$。
 
-我们遍历 `board` 的每一个空格，枚举它可以填入的数字 `v`，如果 `v` 在当前行、当前列、当前 3x3 宫格中没有出现过，那么我们就可以尝试填入数字 `v`，并继续搜索下一个空格。如果搜索到最后，所有空格填充完毕，那么就说明找到了一个可行解。
-
-时间复杂度 $O(9^{81})$，空间复杂度 $O(9^2)$。
+我们遍历 $\textit{board}$ 中的每一个空格，枚举它可以填入的数字 $v$，如果 $v$ 在当前行、当前列、当前 3x3 宫格中没有出现过，那么我们就可以尝试填入数字 $v$，并继续搜索下一个空格。如果搜索到最后，所有空格填充完毕，那么就说明找到了一个可行解。
 
 <!-- tabs:start -->
 
@@ -161,16 +159,14 @@ class Solution {
 #### C++
 
 ```cpp
-using pii = pair<int, int>;
-
 class Solution {
 public:
     void solveSudoku(vector<vector<char>>& board) {
         bool row[9][9] = {false};
         bool col[9][9] = {false};
         bool block[3][3][9] = {false};
         bool ok = false;
-        vector<pii> t;
+        vector<pair<int, int>> t;
         for (int i = 0; i < 9; ++i) {
             for (int j = 0; j < 9; ++j) {
                 if (board[i][j] == '.') {
@@ -181,7 +177,7 @@ public:
                 }
             }
         }
-        function<void(int k)> dfs = [&](int k) {
+        auto dfs = [&](this auto&& dfs, int k) -> void {
             if (k == t.size()) {
                 ok = true;
                 return;
@@ -250,133 +246,41 @@ func solveSudoku(board [][]byte) {
 ```cs
 public class Solution {
     public void SolveSudoku(char[][] board) {
-        this.board = new ushort?[9,9];
-        for (var i = 0; i < 9; ++i)
-        {
-            for (var j = 0; j < 9; ++j)
-            {
-                if (board[i][j] != '.')
-                {
-                    this.board[i, j] = (ushort) (1 << (board[i][j] - '0' - 1));
-                }
-            }
-        }
+        bool[,] row = new bool[9, 9];
+        bool[,] col = new bool[9, 9];
+        bool[,,] block = new bool[3, 3, 9];
+        bool ok = false;
+        var t = new List<(int, int)>();
 
-        if (SolveSudoku(0, 0))
-        {
-            for (var i = 0; i < 9; ++i)
-            {
-                for (var j = 0; j < 9; ++j)
-                {
-                    if (board[i][j] == '.')
-                    {
-                        board[i][j] = '0';
-                        while (this.board[i, j].Value != 0)
-                        {
-                            board[i][j] = (char)(board[i][j] + 1);
-                            this.board[i, j] >>= 1;
-                        }
-                    }
+        for (int i = 0; i < 9; ++i) {
+            for (int j = 0; j < 9; ++j) {
+                if (board[i][j] == '.') {
+                    t.Add((i, j));
+                } else {
+                    int v = board[i][j] - '1';
+                    row[i, v] = col[j, v] = block[i / 3, j / 3, v] = true;
                 }
             }
         }
-    }
 
-    private ushort?[,] board;
-
-    private bool ValidateHorizontalRule(int row)
-    {
-        ushort temp = 0;
-        for (var i = 0; i < 9; ++i)
-        {
-            if (board[row, i].HasValue)
-            {
-                if ((temp | board[row, i].Value) == temp)
-                {
-                    return false;
-                }
-                temp |= board[row, i].Value;
-            }
-        }
-        return true;
-    }
-
-    private bool ValidateVerticalRule(int column)
-    {
-        ushort temp = 0;
-        for (var i = 0; i < 9; ++i)
-        {
-            if (board[i, column].HasValue)
-            {
-                if ((temp | board[i, column].Value) == temp)
-                {
-                    return false;
-                }
-                temp |= board[i, column].Value;
+        void Dfs(int k) {
+            if (k == t.Count) {
+                ok = true;
+                return;
             }
-        }
-        return true;
-    }
-
-    private bool ValidateBlockRule(int row, int column)
-    {
-        var startRow = row / 3 * 3;
-        var startColumn = column / 3 * 3;
-        ushort temp = 0;
-        for (var i = startRow; i < startRow + 3; ++i)
-        {
-            for (var j = startColumn; j < startColumn + 3; ++j)
-            {
-                if (board[i, j].HasValue)
-                {
-                    if ((temp | board[i, j].Value) == temp)
-                    {
-                        return false;
-                    }
-                    temp |= board[i, j].Value;
+            var (i, j) = t[k];
+            for (int v = 0; v < 9; ++v) {
+                if (!row[i, v] && !col[j, v] && !block[i / 3, j / 3, v]) {
+                    row[i, v] = col[j, v] = block[i / 3, j / 3, v] = true;
+                    board[i][j] = (char)(v + '1');
+                    Dfs(k + 1);
+                    if (ok) return;
+                    row[i, v] = col[j, v] = block[i / 3, j / 3, v] = false;
                 }
             }
         }
-        return true;
-    }
-
-    private bool SolveSudoku(int i, int j)
-    {
-        while (true)
-        {
-            if (j == 9)
-            {
-                ++i;
-                j = 0;
-            }
-            if (i == 9)
-            {
-                return true;
-            }
-            if (board[i, j].HasValue)
-            {
-                ++j;
-            }
-            else
-            {
-                break;
-            }
-        }
 
-        ushort stop = 1 << 9;
-        for (ushort t = 1; t != stop; t <<= 1)
-        {
-            board[i, j] = t;
-            if (ValidateHorizontalRule(i) && ValidateVerticalRule(j) && ValidateBlockRule(i, j))
-            {
-                if (SolveSudoku(i, j + 1))
-                {
-                    return true;
-                }
-            }
-        }
-        board[i, j] = null;
-        return false;
+        Dfs(0);
     }
 }
 ```
@@ -386,78 +290,52 @@ public class Solution {
 ```php
 class Solution {
     /**
-     * @param string[][] $board
-     * @return bool
+     * @param String[][] $board
+     * @return NULL
      */
-
-    public function solveSudoku(&$board) {
-        if (isSolved($board)) {
-            return true;
-        }
-
-        $emptyCell = findEmptyCell($board);
-        $row = $emptyCell[0];
-        $col = $emptyCell[1];
-
-        for ($num = 1; $num <= 9; $num++) {
-            if (isValid($board, $row, $col, $num)) {
-                $board[$row][$col] = (string) $num;
-                if ($this->solveSudoku($board)) {
-                    return true;
+    function solveSudoku(&$board) {
+        $row = array_fill(0, 9, array_fill(0, 9, false));
+        $col = array_fill(0, 9, array_fill(0, 9, false));
+        $block = array_fill(0, 3, array_fill(0, 3, array_fill(0, 9, false)));
+        $ok = false;
+        $t = [];
+
+        for ($i = 0; $i < 9; ++$i) {
+            for ($j = 0; $j < 9; ++$j) {
+                if ($board[$i][$j] === '.') {
+                    $t[] = [$i, $j];
+                } else {
+                    $v = ord($board[$i][$j]) - ord('1');
+                    $row[$i][$v] = true;
+                    $col[$j][$v] = true;
+                    $block[intval($i / 3)][intval($j / 3)][$v] = true;
                 }
-                $board[$row][$col] = '.';
             }
         }
-        return false;
-    }
-}
-
-function isSolved($board) {
-    foreach ($board as $row) {
-        if (in_array('.', $row)) {
-            return false;
-        }
-    }
-    return true;
-}
 
-function findEmptyCell($board) {
-    for ($row = 0; $row < 9; $row++) {
-        for ($col = 0; $col < 9; $col++) {
-            if ($board[$row][$col] === '.') {
-                return [$row, $col];
+        $dfs = function ($k) use (&$dfs, &$board, &$row, &$col, &$block, &$ok, &$t) {
+            if ($k === count($t)) {
+                $ok = true;
+                return;
             }
-        }
-    }
-
-    return null;
-}
-
-function isValid($board, $row, $col, $num) {
-    for ($i = 0; $i < 9; $i++) {
-        if ($board[$row][$i] == $num) {
-            return false;
-        }
-    }
-
-    for ($i = 0; $i < 9; $i++) {
-        if ($board[$i][$col] == $num) {
-            return false;
-        }
-    }
-
-    $startRow = floor($row / 3) * 3;
-    $endCol = floor($col / 3) * 3;
-
-    for ($i = 0; $i < 3; $i++) {
-        for ($j = 0; $j < 3; $j++) {
-            if ($board[$startRow + $i][$endCol + $j] == $num) {
-                return false;
+            [$i, $j] = $t[$k];
+            for ($v = 0; $v < 9; ++$v) {
+                if (!$row[$i][$v] && !$col[$j][$v] && !$block[intval($i / 3)][intval($j / 3)][$v]) {
+                    $row[$i][$v] = $col[$j][$v] = $block[intval($i / 3)][intval($j / 3)][$v] = true;
+                    $board[$i][$j] = chr($v + ord('1'));
+                    $dfs($k + 1);
+                    if ($ok) {
+                        return;
+                    }
+                    $row[$i][$v] = $col[$j][$v] = $block[intval($i / 3)][intval($j / 3)][
+                        $v
+                    ] = false;
+                }
             }
-        }
-    }
+        };
 
-    return true;
+        $dfs(0);
+    }
 }
 ```