LeetCode之旅：36. 有效的数独

题意：

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

1、数字 1-9 在每一行只能出现一次。
2、数字 1-9 在每一列只能出现一次。
3、数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

示例 1:
输入:
[
[“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”]
]
输出: true

示例 2:
输入:
[
[“8”,“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”]
]
输出: false

解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

说明:
一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 ‘.’ 。
给定数独永远是 9x9 形式的。

解法一（暴力法）：

1、这道题给定一个二维的vector，里面存放着char类型的元素，元素只可能是1-9或者‘.’

这个二维的vector的行数和列数都是9，要求根据以下规则判断填入的数字是否有效：

①一共9行，1-9的数字在每一行中，每个数字只能出现一次。

②一共9列，1-9的数字在每一列中，每个数字只能出现一次。

③一共9个方块，每个方块都是3行3列的，1-9的数字在每个方块中，每个数字只能出现一次。

2、这道题不难，判断三个规则是否成立，我们只需用暴力解法。

一个四重循环，用来判断每个方块是否1-9的数字只出现一次。

一个双重循环用来判断每一行是否1-9的数字只出现一次。

一个双重循环用来判断每一列是否1-9的数字只出现一次。

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        
        unordered_set<char>s1;//定义一个不排序的set，用来存储char类型的数字
        int count;//用来记录有多少个数字
        
        for(int i=0;i<3;++i)//把9行分成3块
        {
            for(int j=0;j<3;++j)//把9列分成3块
            {
                count=0;
                s1.clear();
                for(int k=0;k<3;++k)//每个方块内部分为3行
                {
                    for(int l=0;l<3;++l)//每个方块内部分为3列
                    {
                        if(board[i*3+k][j*3+l]!='.')//如果是数字
                        {
                            s1.insert(board[i*3+k][j*3+l]);//插入存储到set中
                            count++;//记录有多少个数字出现
                        }
                    }
                }
                if(s1.size()!=count)//如果不相等，说明有重复的数字出现
                    return false;
            }
        }
        
        for(int i=0;i<9;++i)//9行
        {
            s1.clear();
            count=0;
            for(int j=0;j<9;j++)//9列，判断每一行是否出现了重复的数字
            {
                if(board[i][j]!='.')
                {
                    s1.insert(board[i][j]);
                    count++;
                }
            }
            if(s1.size()!=count)
                return false;
        }
        
        for(int j=0;j<9;j++)//9列
        {
            s1.clear();
            count=0;
            for(int i=0;i<9;i++)//9行，判断每一列有没有出现重复的数字
            {
                if(board[i][j]!='.')
                {
                    s1.insert(board[i][j]);
                    count++;
                }
            }
            if(s1.size()!=count)
                return false;
        }
        
        return true;//如果都没有返回false，那么说明三个规则都满足，那么返回true
    }
};

解法二：

一次迭代。

首先，让我们来讨论下面两个问题：

1、如何枚举子数独？
可以使用 box_index = (row / 3) * 3 + columns / 3，其中 / 是整数除法。
2、如何确保行 / 列 / 子数独中没有重复项？
可以利用 value -> count 哈希映射来跟踪所有已经遇到的值。

现在，我们完成了这个算法的所有准备工作：

1）遍历数独。
2）检查看到每个单元格值是否已经在当前的行 / 列 / 子数独中出现过：
如果出现重复，返回 false。
如果没有，则保留此值以进行进一步跟踪。
3）返回 true。

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        vector<map<int, int>> rows(9);
        vector<map<int, int>> columns(9);
        vector<map<int, int>> boxes(9);
        
        for(int i = 0; i < 9; ++i){
            for(int j = 0; j < 9; ++j){
                char num = board[i][j];
                
                if(num != '.'){
                    int n = (int)num;
                    int boxIndex = i / 3 * 3 + j / 3;
                    
                    // 把 n 当做 key,其对应 value自加 1
                    ++rows[i][n];
                    ++columns[j][n];
                    ++boxes[boxIndex][n];
                    
                    // 若 key = n 对应的 value > 1，说明有重复数字
                    if(rows[i][n] > 1 || columns[j][n] > 1 \
                    	|| boxes[boxIndex][n] > 1)
                        return false;
                }
            }
        }
        
        return true;
    }
};

解法三：

我们有个小技巧,我们只需要用一个集合就可以搞定!

比如我们把board[i][j]

用字符串：

表示行：string(i) + board[i][j]

表示列：board[i][j] + string(j)

表示小正方形：string(i/3) + board[i][j] + string(j/3)

就直接可以用一个集合搞定！

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        set<string> boardSet;
        
        for(int i = 0; i < 9; ++i){
            for(int j = 0; j < 9; ++j){
                char num = board[i][j];
                
                if(num != '.'){
                    string row, col, box; 
 
                    row += string(i); row += num;
                    col += num; col += string(j);
                    box += string(i / 3); box += num; box += string(j / 3); 
                    
                    if(!boardSet.insert(row).second || \ 
                       !boardSet.insert(col).second || !boardSet.insert(box).second)
                        return false;
                }
            }
        }
        
        return true;
    }
};

解法一比较笨，解法二和解法三本质相同。