LeetCode: sudoku solver and valid sudoku

最新推荐文章于 2020-07-29 14:35:34 发布

denisewu

最新推荐文章于 2020-07-29 14:35:34 发布

阅读量342

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/denisewu/article/details/44202965

版权

算法专栏收录该内容

15 篇文章 0 订阅

订阅专栏

problem: valid sudoku

Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.

A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.

思路;

使用bool型二维数组来记录每个数字在每个column，每个row，以及每个（3 * 3）的box是否存在。例如二维数组cols[i][j]标志着数字 i + 1在第 j + 1个column是否存在。

代码：

class Solution {
public:
    bool isValidSudoku(vector<vector<char> > &board) {
        bool col[9][9], row[9][9], box[9][9];
        memset(col, 0, 81 * sizeof(bool));
        memset(row, 0, 81 * sizeof(bool));
        memset(box, 0, 81 * sizeof(bool));
        for(int i = 0; i < board.size(); i++)
            for(int j = 0; j < board[i].size(); j++)
            {
                char c = board[i][j];
                if(c != '.')
                {
                    int num = c - '0' - 1;
                    int boxIndex = (i / 3) * 3 + (j / 3);
                    if(col[num][i] || row[num][j] || box[num][boxIndex])
                        return false;
                    col[num][i] = row[num][j] = box[num][boxIndex] = true;
                }
            }
        return true;
    }
};

Leetcode另一道题：

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character '.'.

You may assume that there will be only one unique solution.

思路：

主要就是使用dfs的思想来解题。另外，可以沿用上一道题目的hash的思想来提高算法的效率。在某个空格处，在试验某个数字i（1 - 9）之前，先在hash矩阵中设置true。在回溯时，将已经设置成true的hash矩阵元素设回false。

代码：

class Solution {
    bool cols[9][9] ;
    bool rows[9][9];
    bool boxes[9][9] ;
    
    bool solveSudokuAux(vector<vector<char> > &board, int pos)
    {   
        if(pos == 81)
            return true;
        int r = pos / 9;
        int c = pos % 9;
        if(board[r][c] != '.')
            return solveSudokuAux(board, pos + 1);
        else
        {
            for(int i = 1; i < 10; i++)
            {
                int boxindex = (r / 3) * 3 + (c / 3);
                if(!cols[i - 1][c] && !rows[i - 1][r] && !boxes[i - 1][boxindex])
                {
                    board[r][c] = i + '0';
                    cols[i - 1][c] = rows[i - 1][r] = boxes[i - 1][boxindex] = true;
                    if(solveSudokuAux(board, pos + 1))
                        return true;
                    board[r][c] = '.';
                    cols[i - 1][c] = rows[i - 1][r] = boxes[i - 1][boxindex] = false;
                }
            }
            return false;
        }
    }
    
public:
    void solveSudoku(vector<vector<char> > &board) {
        memset(cols, 0, 81 * sizeof(bool));
        memset(rows, 0, 81 * sizeof(bool));
        memset(boxes, 0, 81 * sizeof(bool));
        for(int i = 0; i < 9; i++)
            for(int j = 0; j < 9; j++)
            {
                if(board[i][j] != '.' )
                {
                    int val = board[i][j] - '0';
                    cols[val - 1][j] = true;
                    rows[val - 1][i] = true;
                    int boxindex = (i / 3) * 3 + (j / 3);
                    boxes[val - 1][boxindex] = true;
                }
            }
        solveSudokuAux(board, 0);
    }
};