update 37 Sudoku Solver

Author: selfboot

Combination/37_SudokuSolver.cpp

@@ -0,0 +1,70 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-07-17 13:59:43
+ */
+
+class Solution {
+private:
+    bool rows_hash[9][9];
+    bool cols_hash[9][9];
+    bool panel_hash[9][9];
+    const vector<int> nums_list = {0,1,2,3,4,5,6,7,8};
+
+    bool dfs_search(int pos, vector<vector<char>>& board){
+        if(pos==81){
+            return true;
+        }
+        int r = pos / 9, c = pos % 9;
+        if(board[r][c] != '.'){
+            return dfs_search(pos+1, board);
+        }
+        else{
+            for(const auto& n: nums_list){
+                if(put_num(n, r, c)){
+                    board[r][c] = '1' + n;
+                    if(dfs_search(pos+1, board)){
+                        return true;
+                    }
+                    board[r][c] = '.';
+                    backtrack(n, r, c);
+                }
+            }
+            return false;
+        }
+    }
+
+    bool put_num(int num, int row, int col){
+        int panel_pos = row / 3 * 3 + col / 3;
+        if(rows_hash[row][num] || cols_hash[col][num] || panel_hash[panel_pos][num]){
+            return false;
+        }
+        rows_hash[row][num] = cols_hash[col][num] = panel_hash[panel_pos][num] = 1;
+        return true;
+    }
+
+    void backtrack(int num, int row, int col){
+        int panel_pos = row / 3 * 3 + col / 3;
+        rows_hash[row][num] = cols_hash[col][num] = panel_hash[panel_pos][num] = 0;
+    }
+
+public:
+    /*
+    According to:
+    https://discuss.leetcode.com/topic/27787/c-clear-solution-using-dfs-beating-90-c-coder
+    */
+    void solveSudoku(vector<vector<char>>& board) {
+        memset(rows_hash, 0, sizeof(rows_hash));
+        memset(cols_hash, 0, sizeof(cols_hash));
+        memset(panel_hash, 0, sizeof(panel_hash));
+
+        for(int i=0; i<9; i++){
+            for(int j=0; j<9;j++){
+                if(board[i][j] != '.'){
+                    int num = board[i][j] - '1';
+                    put_num(num, i, j);
+                }
+            }
+        }
+        dfs_search(0, board);
+    }
+};

Combination/37_SudokuSolver.py

@@ -0,0 +1,67 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+class Solution(object):
+    nums_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+    def solveSudoku(self, board):
+        """ Hash and Backtracking.
+
+        :type board: List[List[str]]
+        :rtype: void Do not return anything, modify board in-place instead.
+        """
+        # Pay Attention, can not define two-degree array as: [[0]*9]*9
+        self.rows_hash, self.cols_hash = [[0] * 9 for i in range(9)], [[0] * 9 for i in range(9)]
+        self.panel_hash = [[0] * 9 for i in range(9)]
+
+        # Add all existing number to hash.
+        for i in xrange(9):
+            for j in xrange(9):
+                if board[i][j] != ".":
+                    self.try_num(int(board[i][j]) - 1, i, j)
+
+        self.dfs_search(0, board)
+
+    def dfs_search(self, cur, board):
+        if cur == 81:
+            return True
+        r, c = cur / 9, cur % 9
+
+        # The existing number must be valid, because we are promised that
+        # there will be only one unique solution.
+        if board[r][c] != ".":
+            return self.dfs_search(cur + 1, board)
+
+        else:
+            for n in self.nums_list:
+                if self.try_num(n - 1, r, c):
+                    board[r][c] = str(n)
+                    if self.dfs_search(cur + 1, board):
+                        return True
+                    # Remember to bacrtrack here.
+                    board[r][c] = "."
+                    self.backtrack(n - 1, r, c)
+            return False
+
+    def try_num(self, num, row, col):
+        panel_pos = row / 3 * 3 + col / 3
+        if (self.rows_hash[row][num] or self.cols_hash[col][num] or
+                self.panel_hash[panel_pos][num]):
+            return False
+        else:
+            self.rows_hash[row][num] = 1
+            self.cols_hash[col][num] = 1
+            self.panel_hash[panel_pos][num] = 1
+            return True
+
+    def backtrack(self, num, row, col):
+        panel_pos = row / 3 * 3 + col / 3
+        self.rows_hash[row][num] = 0
+        self.cols_hash[col][num] = 0
+        self.panel_hash[panel_pos][num] = 0
+
+"""
+["..9748...","7........",".2.1.9...","..7...24.",".64.1.59.",".98...3..","...8.3.2.","........6","...2759.."]
+["53..7....","6..195...",".98....6.","8...6...3","4..8.3..1","7...2...6",".6....28.","...419..5","....8..79"]
+"""

HashTable/36_ValidSudoku.cpp

@@ -1,12 +1,13 @@
 /*
  * @Author: [email protected]
- * @Last Modified time: 2016-07-13 21:09:57
+ * @Last Modified time: 2016-07-17 10:15:37
  */
 
 class Solution
 {
 public:
-    /*
+    /* Hash Table
+    Use three 9*9 array to keep the used numbers in row, col, panel.
     According to:
     https://discuss.leetcode.com/topic/8241/my-short-solution-by-c-o-n2
     */

README.md

@@ -310,6 +310,7 @@
 # Combination
 
 * 030. [Substring with Concatenation of All Words](Combination/30_SubstringWithConcatenationOfAllWords.py)
+* 037. [Sudoku Solver](Combination/37_SudokuSolver.py)
 * 140. [Word Break II](Combination/140_WordBreakII.py)
 * 146. [LRU Cache](Combination/146_LRUCache.py)
 * 300. [Longest Increasing Subsequence](Combination/300_LongestIncreasingSubsequence.py)