Leetcode 37. Resolviendo Sudoku

1. Descripción del tema:

Escriba un programa que resuelva problemas de Sudoku llenando los espacios en blanco.

La solución de Sudoku debe seguir las siguientes reglas:

• Los números del 1 al 9 solo pueden aparecer una vez por línea.
• Los números del 1 al 9 solo pueden aparecer una vez en cada columna.
• Los números del 1 al 9 solo pueden aparecer una vez en cada casa de 3x3 separados por líneas continuas gruesas. (Consulte la imagen de ejemplo)

Los números se han llenado en los espacios en blanco de la parte de Sudoku, y los espacios en blanco están representados por '.'.

1. Ejemplo 1:
   • ingresar:

     board = 
     [["5","3",".",".","7",".",".",".","."],
      ["6",".",".","1","9","5",".",".","."],
      [".","9","8",".",".",".",".","6","."],
      ["8",".",".",".","6",".",".",".","3"],
      ["4",".",".","8",".","3",".",".","1"],
      ["7",".",".",".","2",".",".",".","6"],
      [".","6",".",".",".",".","2","8","."],
      [".",".",".","4","1","9",".",".","5"],
      [".",".",".",".","8",".",".","7","9"]]
     

   • producción:

     [["5","3","4","6","7","8","9","1","2"],
      ["6","7","2","1","9","5","3","4","8"],
      ["1","9","8","3","4","2","5","6","7"],
      ["8","5","9","7","6","1","4","2","3"],
      ["4","2","6","8","5","3","7","9","1"],
      ["7","1","3","9","2","4","8","5","6"],
      ["9","6","1","5","3","7","2","8","4"],
      ["2","8","7","4","1","9","6","3","5"],
      ["3","4","5","2","8","6","1","7","9"]]
     

   • Explicación: la entrada de Sudoku es como se muestra arriba, y la única solución válida es la siguiente:

• pista:
  • tabla.longitud == 9
  • tablero[i].longitud == 9
  • tablero[i][j] es un solo dígito (1-9) o '.'
  • Los datos de la pregunta garantizan que el Sudoku de entrada tiene una sola solución.

2. Soluciones y códigos

1. Soluciones

• Análisis: Resuelva esta pregunta con la ayuda de la pregunta Leetcode36, la idea de resolver el número único y el método recursivo
  • paso 1: en el estado inicial, cuenta los números que han aparecido en cada fila, cada columna y cada palacio de 3x3.
    • Por ejemplo, en la instancia 1:
      • fila[0] = [5, 3, 7], fila[0] representa los números existentes en la fila 0
      • col[0] = [5, 6, 8, 4, 7], col[0] significa el número que ya está en la columna 0
      • x33[0] = [5, 3, 6, 9, 8], x33[0] representa el número existente en la casa 0th 3x3
      • …
  • paso 2: Comience a resolver el número único.
    • (1) Determinar los números candidatos cuyos elementos son '.' en el tablero. Recorra el tablero, cuando fila i, columna j tablero[i][j]='.', de acuerdo con fila[i],col[j],x33[i//3*3+j//3] Cuenta los números que han aparecido y determinar los números candidatos.
      • Por ejemplo, en la instancia 1, fila 0, columna 2
        • fila[0] = [5, 3, 7]
        • columna[2] = [8]
        • x33[0//3*3+2//3] = x33[0] = [5, 3, 6, 9, 8]
      • Entonces los números candidatos para el tablero[0][2] son: [1, 2, 4]. Cuente todos los números candidatos cuyos elementos son '.' en el tablero, use temp para registrar, temp = {(0,2):[1, 2, 4], …}
    • (2) Determinar el elemento en cada posición clave=(i,j) en temp. La idea de recursividad se usa aquí: la condición para el salto recursivo es len(temp)=0
      • Por ejemplo, en la instancia 1, fila 0, columna 2
        • 当$tablero\left[0\right]\left[2\right]\_\_\_\_=1$ , luego volveremos alpaso 1y continuaremos determinando
          • Si len(temp)=0, entonces $tablero\left[0\right]\left[2\right]\_\_\_\_=La\; solución\; de\; 1$ es correcta.
          • Si len(temp)>0, entonces $tablero\left[0\right]\left[2\right]\_\_\_\_=La\; solución\; de\; 1$ es incorrecta. Sea$tablero\left[0\right]\left[2\right]\_\_\_\_=2$ , continúe el bucle hasta que se atraviesen todos los números en [1, 2, 4]. Definitivamente se encontrará una solución, porquelos datos de la pregunta garantizan que solo hay una solución para el Sudoku de entrada.

2. Código

from typing import *
class Solution:
    def getUnused(self, board):
        row = {
    
    0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[]}
        col = {
    
    0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[]}
        x33 = {
    
    0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[]}
        for i in range(len(board)):
            for j in range(len(board[0])):
                if board[i][j]=='.': continue
                row[i].append(board[i][j])
                col[j].append(board[i][j])
                x33[i//3*3+j//3].append(board[i][j])

        all = {
    
    '1','2','3','4','5','6','7','8','9'}
        temp = {
    
    }
        for i in range(len(board)):
            for j in range(len(board[0])):
                if board[i][j]=='.':   
                    temp[(i,j)] = all-set(row[i]+col[j]+x33[i//3*3+j//3])
        # tempSort = dict(sorted(temp.items(), key=lambda k: len(k[1])) )
        return tempSort
        
    def backtracking(self, board, temp):
        for key,vals in temp.items():
            i, j = key
            for val in list(vals):
                board[i][j] = val
                temp = self.getUnused(board)
                if self.backtracking(board, temp): return True
                board[i][j] = '.'
            return False
        return True
    
    def solveSudoku(self, board: List[List[str]]) -> None:
        tempSort = self.getUnused(board)        
        self.backtracking(board, tempSort)
        return