C++ 如何想出这样的解决方案？（检查数独是否有效）

问题是确定数独是否有效

要解决此问题，只需检查问题中所述的3条规则

每行数字1-9必须只出现一次

每列的数字1-9必须只出现一次

并且数字1-9必须在网格的9个子框中的每一个子框中出现一次

所以我想了一会儿，想出了一个类似的解决方案： 这并不是什么大问题，因为首先对行进行哈希，然后对列进行哈希，最后对子矩阵进行哈希

class Solution {
public:
    bool isValidSudoku(vector<vector<char> > &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        map<char, bool> row;
        map<char, bool> col;
        map<char, bool> block;

        for (int i=0;i<9;i++){
            col.clear();
            row.clear();
            for (int j=0;j<9;j++){
                if (board[i][j]!='.'){
                    if (col[board[i][j]]){
                        return false;
                    }else{
                        col[board[i][j]]=true;
                    }
                }
                if (board[j][i]!='.'){
                    if (row[board[j][i]]){
                        return false;
                    }else{
                        row[board[j][i]]=true;
                    }
                }
            }
        }

        for (int ii=0;ii<9;ii=ii+3){
            for (int jj=0;jj<9;jj=jj+3){
                block.clear();
                for (int i=ii;i<ii+3;i++){
                    for (int j=jj;j<jj+3;j++){
                        if (board[i][j]!='.'){
                            if (block[board[i][j]]){
                                return false;
                            }else{
                                block[board[i][j]]=true;
                            }
                        }
                    }
                }       
            }
        }

        return true;
    }
};

类解决方案{
公众：
bool isValidSudoku（矢量和板）{
//开始在下面键入您的C/C++解决方案
//不要编写int main（）函数
地图行；
地图颜色；
地图块；
对于（int i=0；i，我们希望从
（行，列）
中获得一个函数，用于块编号。下面是我们希望看到的结果图

000 111 222
000 111 222
000 111 222
333 444 555
333 444 555
333 444 555
666 777 888
666 777 888
666 777 888

让我们看一下第一行。这种重复的结构来自整数除法。因此，如果您尝试
col/3
，您将得到确切的第一行

现在让我们看看整个表。让我们从所有行中减去第一个表达式，这样它将显示所有
A[row][col]
，这样
A[row][col]+col/3=block\u no

000 000 000
000 000 000
000 000 000
333 333 333
333 333 333
333 333 333
666 666 666
666 666 666
666 666 666

嘿，它不再依赖于列数。如果你将其除以3，你将看到我们刚刚使用的结构，并决定需要
行/3

总之：
col/3+3*（row/3）

右边的部分看起来很像一个“四舍五入到3的最近倍数”的运算。它可以通过另一种方式实现：你可以减去最近倍数上的所有值。这正是模运算符所做的。所以我们可以将它简化为

代码> COL/3行行3 %/代码> < /P>你理解模数算符吗？是的，我不明白他是怎么想出公式的，考虑在TopMeor或USACO上的训练。经过几个星期的训练，你会觉得这是一项非常简单的任务。
000 000 000
000 000 000
000 000 000
333 333 333
333 333 333
333 333 333
666 666 666
666 666 666
666 666 666