leetcode@ [36/37] Valid Sudoku / Sudoku Solver

https://leetcode.com/problems/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 partially filled sudoku which is valid.

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

class Solution {
public:
    vector<int> getIdx(int i, int j) {
        vector<int> idx();
        int row, col;
        if(i>= && i<=) {
            idx[] = ; idx[] = ;
        }
        else if(i>= && i<=) {
            idx[] = ; idx[] = ;
        }
        else if(i>= && i<=) {
            idx[] = ; idx[] = ;
        }

        if(j>= && j<=) {
            idx[] = ; idx[] = ;
        }
        else if(j>= && j<=) {
            idx[] = ; idx[] = ;
        }
        else if(j>= && j<=) {
            idx[] = ; idx[] = ;
        }

        return idx;
    }
    bool checkRowAndColumn(vector<vector<char>>& board, int i, int j) {
        if(i< || i>=board.size() || j< || j>=board[].size()) return false;

        for(int ni=;ni<board.size();++ni) {
            if(ni == i || board[ni][j] == '.') continue;
            if(board[ni][j] == board[i][j]) return false;
        }

        for(int nj=;nj<board[].size();++nj) {
            if(nj == j || board[i][nj] == '.') continue;
            if(board[i][nj] == board[i][j]) return false;
        }

        return true;
    }

    bool checkLocal(vector<vector<char>>& board, int i, int j) {
        if(i< || i>=board.size() || j< || j>=board[].size()) return false;

        vector<int> idx = getIdx(i, j);
        int li = idx[], ri = idx[], lj = idx[], rj = idx[];

        for(int p=li;p<=ri;++p) {
            for(int q=lj;q<=rj;++q) {
                if((i==p && j==q) || board[p][q] == '.') continue;
                if(board[i][j] == board[p][q]) return false;
            }
        }

        return true;
    }
    bool isValidSudoku(vector<vector<char>>& board) {
        for(int i=;i<board.size();++i) {
            for(int j=;j<board[i].size();++j) {
                if(board[i][j] == '.') continue;
                if(!checkLocal(board, i, j) || !checkRowAndColumn(board, i, j)) return false;
            }
        }
        return true;
    }
};

填写九宫格：

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.

A sudoku puzzle...

...and its solution numbers marked in red.

class Solution {
public:
    vector<int> getNext(vector<vector<char>>& board, int x, int y) {
        vector<int> next; next.clear();
        for(int j=y;j<board[].size();++j) {
            if(board[x][j] == '.') {
                next.push_back(x); next.push_back(j);
                return next;
            }
        }
        for(int i=x+;i<board.size();++i) {
            for(int j=;j<board[i].size();++j) {
                if(board[i][j] == '.') {
                    next.push_back(i); next.push_back(j);
                    return next;
                }
            }
        }
        return next;
    }
    vector<int> getIdx(int i, int j) {
        vector<int> idx();
        int row, col;
        if(i>= && i<=) {idx[] = ; idx[] = ;  }
        else if(i>= && i<=) {idx[] = ; idx[] = ;  }
        else if(i>= && i<=) {idx[] = ; idx[] = ;  }

        if(j>= && j<=) {idx[] = ; idx[] = ;  }
        else if(j>= && j<=) {idx[] = ; idx[] = ;  }
        else if(j>= && j<=) {idx[] = ; idx[] = ;  }

        return idx;
    }
    bool checkRowAndColumn(vector<vector<char>>& board, int i, int j) {
        if(i< || i>=board.size() || j< || j>=board[].size()) return false;

        for(int ni=;ni<board.size();++ni) {
            if(ni == i || board[ni][j] == '.') continue;
            if(board[ni][j] == board[i][j]) return false;
        }

        for(int nj=;nj<board[].size();++nj) {
            if(nj == j || board[i][nj] == '.') continue;
            if(board[i][nj] == board[i][j]) return false;
        }

        return true;
    }

    bool checkLocal(vector<vector<char>>& board, int i, int j) {
        if(i< || i>=board.size() || j< || j>=board[].size()) return false;

        vector<int> idx = getIdx(i, j);
        int li = idx[], ri = idx[], lj = idx[], rj = idx[];

        for(int p=li;p<=ri;++p) {
            for(int q=lj;q<=rj;++q) {
                if((i==p && j==q) || board[p][q] == '.') continue;
                if(board[i][j] == board[p][q]) return false;
            }
        }

        return true;
    }

    bool dfs(vector<vector<char>>& board, vector<vector<char>>& res, int x, int y) {
        vector<int> next = getNext(board, x, y);
        if(next.empty()) {
            return true;
        }

        int nx = next[], ny = next[];
        for(int nn = ; nn <= ; ++nn) {
            board[nx][ny] = nn + '';
            if(checkLocal(board, nx, ny) && checkRowAndColumn(board, nx, ny)) {
                if(dfs(board, res, nx, ny)) {
                    res[nx][ny] = nn + '';
                    return true;
                }
            }
        }
        return false;
    }
    void solveSudoku(vector<vector<char>>& board) {
        vector<vector<char> > res = board;
        dfs(board, res, , );

        board = res;
    }
};