回溯算法-N皇后、解数独

重新安排行程题都看不懂，选择放弃

N皇后（困难）

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位

题目解析：

• 首先是函数的参数和返回值，这里题目要求返回不同的正确的棋盘，所以还是一样，返回值为void，用全局变量res来盛放结果，对于参数值，首先要思考startIndex，也就是在纵向时，如何迭代，发现startIndex就是棋盘的行，纵向遍历就表示到达下一行，那么相应的，横向遍历就是遍历列了
• 终止条件：startIndex遍历要最后最后一行就结束
• 遍历方式：横向遍历就是列的遍历，纵向遍历就是行的遍历
• 放置皇后规则，就是判断横竖、左斜和右斜
• 代码：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        
        vector<string> path(n, string(n, '.')); //根据题目，将其初始化为'.'
        func(n, path, 0);//注意相比以往的题目，我们要将path传进去，每次回溯都要传入path，因为要进行判断棋盘是否合法
        return res;
    }
private:
    vector<vector<string>> res;
    void func(int n, vector<string> path, int row)
    {
        if (row == n)
        {
            res.push_back(path);
            return;
        }
        for(int col = 0; col < n; col++)
        {
            
            path[row][col] = 'Q';
            if (isValid(path, row, col))
            {
                func(n, path, row + 1);
            }
            path[row][col] = '.';
            
        }
        return;
    }
    bool isValid(vector<string>& str, int row, int col)
    {
        for (int i = 0; i < col; i++)
        {
            if (str[row][i] == 'Q') return false;
        }
        for (int i = 0; i < row; i++)
        {
            if (str[i][col] == 'Q') return false;
        }
        for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--)
        {
            if (str[i][j] == 'Q') return false;
        }
        for (int i = row - 1, j = col + 1; i >=0 && j < str.size(); i--, j++)
        {
            if (str[i][j] == 'Q') return false;
        }
        return true;

    }
};

解数独（困难）

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

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

题目解析：

• 首先是函数的参数和返回值，这里题目要求返回一个正确的解即可，并不是所有可能的解集，返回值依然用bool，参数每次回溯时就要传入当前的解，其次要思考startIndex，这里比较难理解，也就是在纵向时，如何迭代，这里需要迭代不同的数字，而不是行或列，要是遍历1-9，看哪个符合，所以没有startIndex
• 终止条件：找到一个结果就终止，所以没有严格意义的终止条件
• 遍历方式：纵向遍历就是数字的遍历，那么横向遍历自然就是行列的遍历了，所以需要两层循环
• 解数独的规则：就是看当前放置的数字是否满足题目要求
• 代码：

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        func(board);
        return;
    }
private:
    bool func(vector<vector<char>>& board)
    {
        for(int i = 0; i < board.size(); i++)
        {
            for(int j = 0; j < board[0].size(); j++)
            {
                if (board[i][j] == '.')
                {
                    for (char h = '1'; h <= '9'; h++)
                    {
                        
                        if (isValid(board, i, j, h))
                        {
                            board[i][j] = h;
                            if (func(board)) return true; //在这里判断是否得到一个正确的解，所以终止条件是隐藏在这里的
                            board[i][j] = '.';
                        }
                        
                    }
                    return false;//数字都不满足，所以返回false
                }
                
            }
        }
        return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
    }
    bool isValid(vector<vector<char>>& board, int row, int col, char c)
    {
        int size = board.size();
        for(int i = 0; i < 9; i++)
        {
            if ( board[i][col] == c) return false;
        }
        for(int i = 0; i < 9; i++)
        {
            if ( board[row][i] == c) return false;
        }
        int startx =  (row / 3) * 3; // 这里的思维逻辑
        int starty =  (col / 3) * 3;
        for(int i = startx; i < startx + 3; i++)
        {
            for (int j = starty; j < starty + 3; j++)
            {
                if(board[i][j] == c) return false; 
            }
            
        }
        return true;
    }
};