Leetcode-Sudoku Solver(数独)

这道题的解题思路如下:

$(1):维护一个list,里面保存所有未确定元素的取值集合$

$(2):每次从list里面取集合长度最小的集合,然后开始进行dfs$

$(3)每确定一个元素,就要更新对应的行,列,block所在的所有元素对应的集合$

$(4)如果搜索失败,在返回的时候需要将相关集合的状态还原$

这道题的编程细节如下:

$(1):在初始化每个元素的对应集合时,先算出每一行,每一列,每一个方块对应的集合,然后对每一个未确定的元素,我们只需要计算它所对应的行,列,方块三个集合的交集,这样就可以算出初始元素的取值集合$

$(2):在还原集合状态时,一定要注意使用copy函数,否则一不小心就会导致两个集合共享一个内存,引起奇怪的bug。另外,利用函数还原集合的时候要使用直接对该集合操作的函数,千万不要直接赋值。这样改变不了集合的状态！只能做一次新的绑定。$

…一些可能的优化:

$(1)$:利用一个判定函数判断当集合元素大于1个的时候,应该优先选择能够筛选掉最多元素的那一个。但是由于数据量比较小,所以这个优化不一定在这种输入下占优势

代码如下:进行一次排序

def get_priority(ele):
                return count[ele]

            if len(candidates)>1:
                count = Counter((chain(*copy_row,*copy_col,*copy_block)))
                copy_candidates.sort(key = get_priority,reverse = True)
            else:
                copy_candidates = candidates.copy()

$(2)$:可以维护一个堆,只有当更新的时候某一个元素的值小于当前堆的最小值时,我们才重建堆。否则就直接从堆里面取最小值(堆顶元素)。同样由于leetcode数据量很小,这个优化不见得能加快。

$-------原始版本代码-------$

class Solution(object):
    def solveSudoku(self, board):
        def gen_pos():
            for i in range(n):
                for j in range(n):
                    yield i,j
        def block_id(i,j):
            return i//3*3+j//3
        def delete(container,d):
            for item in container:
                item.discard(d)

        def recover(container,initial):
            for item_c,item_ini in zip(container,initial):
                item_c.clear()
                item_c.update(item_ini)

        def update():
            if len(cells)==0:return True
            (candidates,index) = min(((c,index) for index,c in cells.items()),key = lambda x:len(x[0]))
            copy_candidates = candidates.copy()
            if len(candidates)==0:return False

            row,col = index//9,index%9
            block = row//3*3+col//3
            copy_row = [cells[r].copy() for r in range(row*9,row*9+9) if r in cells]
            copy_col = [cells[c].copy() for c in range(col,81,9) if c in cells]
            copy_block = [cells[b].copy() for b in block_indexs[block] if b in cells]

            for selected in copy_candidates:

                delete((cells[r] for r in range(row*9,row*9+9) if r in cells),selected)
                delete((cells[c] for c in range(col,81,9) if c in cells),selected)
                delete((cells[b] for b in block_indexs[block] if b in cells),selected)
                result_board[index//9][index%9] = selected
                cells.pop(index)

                if not update():
                    cells[index] = copy_candidates.copy()####fuck
                    recover((cells[r] for r in range(row*9,row*9+9) if r in cells),copy_row)
                    recover((cells[c] for c in range(col,81,9) if c in cells),copy_col)
                    recover((cells[b] for b in block_indexs[block] if b in cells),copy_block)
                else:
                    return True
            return False

        n = len(board)
        all_num = {str(i+1) for i in range(n)}
        rows = [all_num-set(row) for row in board]
        cols = [all_num-set(col) for col in zip(*(row for row in board))]
        blocks,block_indexs = [set() for i in range(n)],[[]for j in range(n)]
        cells = [ [] for i in range(n*n) ]
        result_board = [[s for s in row] for row in board]

        for i,j in gen_pos():
            index = block_id(i,j)
            blocks[index].add(board[i][j])
            block_indexs[index].append(i*9+j)
        blocks = {index:all_num-item_set for index,item_set in enumerate(blocks) }
        cells = {i*9+j:(rows[i]&cols[j]&blocks[block_id(i,j)]) \
        for i,j in gen_pos() if board[i][j]=='.'}


        update()
        for i,(v1,v2) in enumerate(zip(board,result_board)):
            board[i] = ''.join(v2)

最后结果: