推荐订阅源

1.经典的N皇后问题

就是个经典的DFS算法

我摆到第一行第一列了哦，然后就开始Deep看下一行，可以放哪，然后递推，直到棋盘的行列到。

  void NQueenHelper(vector<vector<string>> & board, vector<vector<string>>& result, int row)
    {
        int N = board.size();
        if (row == N)//reached end scenario
        {
            string str;
            vector<string> final;
            for (int i = 0; i<N; i++)
            {
                for (int j = 0; j<N; j++)
                {
                    str.push_back(board[i][j][0]);
                }
    
                final.push_back(str);
                str.clear();
            }
            result.push_back(final);
        }
    
        for (int col = 0; col < N; col++)
        {
            if (isValidMove(board, row, col))
            {
                board[row][col] = "Q";
                NQueenHelper(board, result, row + 1);
                board[row][col] = ".";
            }
        }
    }

其中判断suduko的解法中，稍微不同的一点在于

isValidMove
八皇后问题

    bool isValidBoard(vector<vector<int>>& board, int col, int row)
    {
        int size = board.size();
        //look at col 
        for(int i =0; i<col ; i++)
        if(board[row][i]) return false;
        
        //look at row
        for(int i = 0;i <row; i++ )
        if(board[i][col]) return false;
        
        //diag
        for(int i= row, j= col; i>=0&&j>=0; i--,j--)
        {
            if(board[i][j]) return false;
        }
        
        for(int i= row, j= col; i>=0&& j<size; i--,j++)
        {
            if(board[i][j]) return false;
        }
        
        return true;
        
    }

而sudoku

判断合法的是

    // 检查往某个位置填入一个数之后整个 board 是否有效（只需要考虑当前行、
    // 当前列和所属的田字格）
    bool isValidBoard(const vector< vector<char> >& board, pair<int, int> pos) {
        // 检查当前行是否有效
        if (!isValid(board[pos.first])) return false;

        // 检查当前列是否有效
        vector<char> column(9);
        for (int i = 0; i < 9; ++i)
            column[i] = board[i][pos.second];
        if (!isValid(column)) return false;

        // 检查所在的田字格是否有效
        int block_row = pos.first / 3;
        int block_col = pos.second / 3;
        vector<char> block;
        for (int i = block_row * 3; i < block_row * 3 + 3; ++i)
            for (int j = block_col * 3; j < block_col * 3 + 3; ++j)
                block.push_back(board[i][j]);
        if (!isValid(block)) return false;

        // 如果以上都有效，则返回 true
        return true;
    }