C++，预处理+位运算

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        this->initCriteria(board);
        this->fill(board, 0, 0);
    }

private:
    vector<int> rowCriteria, colCriteria, cellCriteria;
    int size = 9, cellSize = 3;
    bool finish = false;

    void initCriteria(vector<vector<char>>& board)
    {
        int cellNum;
        char numChar;

        this->rowCriteria = vector<int>(this->size, 0);
        this->colCriteria = vector<int>(this->size, 0);
        this->cellCriteria = vector<int>(this->size, 0);

        for (int x = 0; x < this->size; x++)
        {
            for (int y = 0; y < this->size; y++)
            {
                if (board[x][y] != '.')
                {
                    numChar = (int)board[x][y] - int('0');
                    this->criteriaAdd(x, y, 1 << numChar);
                }
            }
        }
    }

    void fill(vector<vector<char>>& board, int x, int y)
    {
        int tmp, cellNum;

        while (x < this->size)
        {
            while (y < this->size)
            {
                if (board[x][y] == '.')
                {
                    for (int i = 1; i <= this->size; i++)
                    {
                        tmp = 1 << i;
                        cellNum = x / this->cellSize * this->cellSize + y / this->cellSize;
                        if ((this->rowCriteria[x] & tmp) == 0 &&
                            (this->colCriteria[y] & tmp) == 0 &&
                            (this->cellCriteria[cellNum] & tmp) == 0)
                        {
                            board[x][y] = char('0' + i);
                            this->criteriaAdd(x, y, tmp);
                            this->fill(board, x, y + 1);
                            if (this->finish)
                            {
                                return;
                            }
                            else
                            {
                                this->criteriaAdd(x, y, tmp, false);
                            }
                        }
                    }
                    board[x][y] = '.';
                    return;
                }
                y++;
            }
            y = 0;
            x++;
        }
        this->finish = true;
    }

    void criteriaAdd(int x, int y, int num, bool add = true)
    {
        int cellNum;

        this->rowCriteria[x] = add ? this->rowCriteria[x] + num : this->rowCriteria[x] - num;
        this->colCriteria[y] = add ? this->colCriteria[y] + num : this->colCriteria[y] - num;

        cellNum = x / this->cellSize * this->cellSize + y / this->cellSize;
        this->cellCriteria[cellNum] = add ? this->cellCriteria[cellNum] + num : this->cellCriteria[cellNum] - num;
    }
};

PHP 实现：

public function solveSudoku(&$board)
  {
    if (!$board) return;
    $this->sudoku($board);
  }
  public function sudoku(&$board)
  {
    for ($i = 0; $i < count($board); $i++) {
      for ($j = 0; $j < count($board[0]); $j++) {
        if ($board[$i][$j] == ".") {
          for ($c = "1"; $c <= "9"; $c++) {
            if ($this->valid($board, $i, $j, $c)) {
              $board[$i][$j] = (string)$c;
              if ($this->sudoku($board)) {
                return true;
              }
              $board[$i][$j] = ".";
            }
          }
          return false;
        }
      }
    }
    return true;
  }

  public function valid($board, $row, $col, $c)
  {

    for ($i = 0; $i < 9; $i++) {
      if ($board[$i][$col] != "." && $board[$i][$col] == $c) return false;
      if ($board[$row][$i] != "." && $board[$row][$i] == $c) return false;
      $x = 3 * floor($row / 3) + floor($i / 3);
      $y = 3 * floor($col / 3) + floor($i % 3);
      if ($board[$x][$y] != "." && $board[$x][$y] == $c) return false;
    }
    return true;
  }