36.有效的数独 Valid Sudoku

题目链接

中文

https://leetcode-cn.com/problems/valid-sudoku/description/

英文

https://leetcode.com/problems/valid-sudoku/description/

解法1

逐行扫描，维护扫描位置的行和列和块标志数组。

分析：
1.标志数组大小为9，用于存放1~9是否在该检查区域出现，若出现则判定为不是数独。当检查区域结束时，维护的数组复位为全部不出现。
2.需要维护的数组个数分析：行扫描情况下，行数组为1个，列数组为9个，块数组为3个。
1）每行扫描结束时检查区域结束，因此只需 1 个行数组。
2）列数组的结束区域全部在最后一行，知道最后一行结束才可以结束列数组，每行9列，因此列数组为9个。
3）块数组每扫描3行到达一次结束区域，复位一次，一共9列，每3列一个块，因此块数组为3个。
2.查重策略：每加入一个非空字符，对当前维护数组的该字符标志位判断，若该字符标志位为true，则不满足数独要求，终止算法，返回假 flase。若该字符标志位为flase,继续下一步。
3.数组更新策略：可以通过当前列j来判断将该字符更新哪个数组。
1）行数组有 1 个，每次扫描都更新该数组。
2）块数组有3个，更新的数组可以根据当前列j来判断，分别3个区域：0 ~ 2更新一号数组，3 ~5更新2号数组，6 ~ 8更新3号数组，因此可以用 j%3来选择更新的数组下标。
3）列数组有9个，更新数组下标和当前列号一致。
4.复位策略：行数组每行复位一次，块数组每3行复位一次，列数组结束才复位。
代码：

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        vector<bool> used(9,false);
        vector<vector<bool> > cols(9,used);
        vector<vector<bool> > squ(3,used);
        for(int i=0;i < board.size();++i){
            //复位工作
            vector<bool> row(used);
            if(i%3==0)
                for(int k=0;k<3;++k)
                    squ[k] = used;
            for(int j=0;j<board[i].size();++j)
            {
                char c = board[i][j];
                if(c!='.')
                {
                    c = c - '1';
                    if( row[c] ==true)
                        return false;
                    row[c]=true;
                    int sn = j/3;
                    if(squ[sn][c]==true)
                        return false;
                    squ[sn][c]=true;
                    if(cols[j][c]==true)
                        return false;
                    cols[j][c]=true;
                }
            }
        }
        return true;
        
    }
};

复杂度分析：
时间复杂度：O(n²):扫描列表复杂度为n²。
空间复杂度：O(1)，维护数组大小为(列数组9 + 块数组 3 + 行数组 1)*数组大小9 = 117.

解法2 记录字符出现的所有位置，并比对位置判断

来源 leetCode

struct Pos {
    int x, y;
};

class Solution {
public:
	/*
		判断两个位置是否在同一列、同一行或者同一个3*3的块中
		若在 返回 false
		若不在 返回 true
	*/
    bool judge(Pos& a, Pos& b) {
        if(	a.x == b.x || //同一列
        	a.y == b.y || //同一行
        	(a.x/3 == b.x/3) && (a.y/3 == b.y/3)) //同一块
            return false;
        return true;
    }
    bool isValidSudoku(vector<vector<char>>& board) {
        //存储0~9所在的所有位置
        vector<vector<Pos> > v(10);
        //遍历所有元素 时间复杂度 n*n
        for(int x = 0; x < 9; ++x) {
            for(int y = 0; y < 9; ++y) {
                if(board[x][y] == '.') continue;
                int idx = board[x][y] - '0';
                Pos pos = {x, y};
               //当字符出现过时
                if(!v[idx].empty()) {
                    //对出现过的所有位置进行对比，判断是否不满足数独条件
                    for(auto p : v[idx]) {
                        if(!judge(p, pos))
                            return false;
                    }
                }
                //将出现位置添加到位置数组中
                v[idx].push_back(pos);
            }
        }
        return true;
    }
};

复杂度分析：
时间复杂度：n³,遍历n²，比对位置最差为n（相同字符最多同时出现9次），最好为1
空间复杂度：O(1),若每个位置都不为空，最高需要占用9*9=81个Pos结构的空间，占用空间和元素个数一致。