目录
一、优美的排列
1. 题目链接：526. 优美的排列
2. 题目描述：
假设有从 1 到 n 的 n 个整数。用这些整数构造一个数组
perm（下标从 1 开始），只要满足下述条件 之一 ，该数组就是一个 优美的排列 ：
perm[i]能够被i整除i能够被perm[i]整除给你一个整数
n，返回可以构造的 优美排列 的 数量 。示例 1：
输入：n = 2 输出：2 解释： 第 1 个优美的排列是 [1,2]： - perm[1] = 1 能被 i = 1 整除 - perm[2] = 2 能被 i = 2 整除 第 2 个优美的排列是 [2,1]: - perm[1] = 2 能被 i = 1 整除 - i = 2 能被 perm[2] = 1 整除示例 2：
输入：n = 1 输出：1提示：
1 <= n <= 15
3. 解法
🌴算法思路：
我们需要在每⼀个位置上考虑所有的可能情况并且不能出现重复。通过深度优先搜索的方式，不断地枚举每个数在当前位置的可能性，并回溯到上⼀个状态，直到枚举完所有可能性，得到正确的结果。
我们需要定义⼀个变量用来记录所有可能的排列数量，⼀个⼀维数组 visited 标记元素，然后从第⼀个位置开始进行递归；
递归函数设计：void backtrack(int pos, int &n)
- 参数：pos（当前需要处理的位置）；
- 返回值：无；
- 函数作用：在当前位置填入一个合理的数字，查找所有满足条件的排列。
递归流程如下：
1. 递归结束条件：当 pos 等于 n+1 时，说明已经处理完了所有数字，将当前数组存入结果中；
2. 在每个递归状态中，枚举所有下标 x，若这个下标未被标记，并且满足题目条件之⼀：
- 将 visited[x] 标记为 1；
- 对第 pos+1 个位置进行递归；
- 将 visited[x] 重新赋值为 0，表示回溯；
🌴算法代码：
class Solution
{
bool check[16];
int ret;
public:
int countArrangement(int n)
{
dfs(1, n);
return ret;
}
void dfs(int pos, int n)
{
if (pos == n + 1)
{
ret++;
return;
}
for (int i = 1; i <= n; i++)
{
if (!check[i] && (check[i] % i == 0 || i % check[i] == 0))
{
check[i] = true;
dfs(pos + 1, n);
check[i] = false;
}
}
}
};二、N 皇后
1.题目链接：51. N 皇后
2.题目描述：
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将
n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数
n，返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中
'Q'和'.'分别代表了皇后和空位。示例 1：
输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。示例 2：
输入：n = 1 输出：[["Q"]]
3.解法
🌵算法思路：
首先，我们在第⼀行放置第⼀个皇后，然后遍历棋盘的第二行，在可行的位置放置第二个皇后，然后再遍历第三行，在可行的位置放置第三个皇后，以此类推，直到放置了 n 个皇后为止。
我们需要用⼀个数组来记录每⼀行放置的皇后的列数。在每⼀行中，我们尝试放置⼀个皇后，并检查是否会和前面已经放置的皇后冲突。如果没有冲突，我们就继续递归地放置下⼀行的皇后，直到所有的皇后都放置完毕，然后把这个方案记录下来。
在检查皇后是否冲突时，我们可以用⼀个数组来记录每⼀列是否已经放置了皇后，并检查当前要放置的皇后是否会和已经放置的皇后冲突。对于对角线，我们可以用两个数组来记录从左上角到右下角的每⼀条对角线上是否已经放置了皇后，以及从右上角到左下角的每⼀条对角线上是否已经放置了皇后。
对于对角线是否冲突的判断可以通过以下流程解决：
- 从左上到右下：相同对角线的行列之差相同；
- 从右上到左下：相同对角线的行列之和相同
因此，我们需要创建用于存储解决方案的二维字符串数组 solutions ，用于存储每个皇后的位置的⼀维整数数组 queens ，以及用于记录每⼀列和对角线上是否已经有皇后的布尔型数组 columns 、 diagonals1 和 diagonals2。
递归函数设计：void dfs(vector<vector<string>> &solutions, vector<int> &queens, int &n, int row, vector<bool> &columns, vector<bool> &diagonals1, vector<bool> &diagonals2)
参数：row（当前需要处理的行数）；
返回值：无；
函数作用：在当前行放入⼀个不发生冲突的皇后，查找所有可行的方案使得放置 n 个皇后后不发生冲突。
递归函数流程如下：
1. 结束条件：如果 row 等于 n ，则表示已经找到⼀组解决方案，此时将每个皇后的位置存储到字符串数组 board 中，并将 board 存储到 solutions 数组中，然后返回；
2. 枚举当前行的每⼀列，判断该列、两个对角线上是否已经有皇后：
a. 如果有皇后，则继续枚举下⼀列；
b. 否则，在该位置放置皇后，并将 columns 、 diagonals1 和 diagonals2 对应的位置设为 true ，表示该列和对角线上已经有皇后：
i. 递归调用 dfs 函数，搜索下⼀行的皇后位置。如果该方案递归结束，则在回溯时需要将 columns 、 diagonals1 和 diagonals2 对应的位置设为 false ，然后继续枚举下⼀列；
🌵算法代码：
class Solution
{
bool chechCol[10], checkDig1[20], checkDig2[20];
vector<vector<string>> ret;
vector<string> path;
int n;
public:
vector<vector<string>> solveNQueens(int _n)
{
n = _n;
path.resize(n);
for (int i = 0; i < n; i++)
path[i].append(n, '.');
dfs(0);
return ret;
}
void dfs(int row)
{
if (row == n)
{
ret.push_back(path);
return;
}
for (int col = 0; col < n; col++)// 尝试在这一列放皇后
{
if (!chechCol[col] && !checkDig1[row - col + n] && !checkDig2[row + col])
{
path[row][col] = 'Q';
chechCol[col] = checkDig1[row - col + n] = checkDig2[row + col] = true;
dfs(row + 1);
// 恢复现场
path[row][col] = '.';
chechCol[col] = checkDig1[row - col + n] = checkDig2[row + col] = false;
}
}
}
};二、有效的数独
1.题目链接：36. 有效的数独
2.题目描述：
请你判断一个
9 x 9的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
- 数字
1-9在每一行只能出现一次。- 数字
1-9在每一列只能出现一次。- 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）注意：
- 一个有效的数独（部分已被填充）不一定是可解的。
- 只需要根据以上规则，验证已经填入的数字是否有效即可。
- 空白格用
'.'表示。示例 1：
输入：board = [["5","3",".",".","7",".",".",".","."] ,["6",".",".","1","9","5",".",".","."] ,[".","9","8",".",".",".",".","6","."] ,["8",".",".",".","6",".",".",".","3"] ,["4",".",".","8",".","3",".",".","1"] ,["7",".",".",".","2",".",".",".","6"] ,[".","6",".",".",".",".","2","8","."] ,[".",".",".","4","1","9",".",".","5"] ,[".",".",".",".","8",".",".","7","9"]] 输出：true示例 2：
输入：board = [["8","3",".",".","7",".",".",".","."] ,["6",".",".","1","9","5",".",".","."] ,[".","9","8",".",".",".",".","6","."] ,["8",".",".",".","6",".",".",".","3"] ,["4",".",".","8",".","3",".",".","1"] ,["7",".",".",".","2",".",".",".","6"] ,[".","6",".",".",".",".","2","8","."] ,[".",".",".","4","1","9",".",".","5"] ,[".",".",".",".","8",".",".","7","9"]] 输出：false 解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。提示：
board.length == 9board[i].length == 9board[i][j]是一位数字（1-9）或者'.'
3.解法
🌵算法思路：
创建三个数组标记行、列以及 3*3 小方格中是否出现 1~9 之间的数字即可。
🌵算法代码：
class Solution
{
bool row[9][10];
bool col[9][10];
bool box[3][3][10];
public:
bool isValidSudoku(vector<vector<char>>& board)
{
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (board[i][j] != '.')
{
int num = board[i][j] - '0';
if (row[i][num] || col[j][num] || box[i / 3][j / 3][num])
return false;
row[i][num] = col[j][num] = box[i / 3][j / 3][num] = true;
}
}
}
return true;
}
};二、解数独
1.题目链接：37. 解数独
2.题目描述：
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
- 数字
1-9在每一行只能出现一次。- 数字
1-9在每一列只能出现一次。- 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用
'.'表示。示例 1：
输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."], [".","9","8",".",".",".",".","6","."], ["8",".",".",".","6",".",".",".","3"], ["4",".",".","8",".","3",".",".","1"], ["7",".",".",".","2",".",".",".","6"], [".","6",".",".",".",".","2","8","."], [".",".",".","4","1","9",".",".","5"], [".",".",".",".","8",".",".","7","9"]] 输出：[["5","3","4","6","7","8","9","1","2"], ["6","7","2","1","9","5","3","4","8"], ["1","9","8","3","4","2","5","6","7"], ["8","5","9","7","6","1","4","2","3"], ["4","2","6","8","5","3","7","9","1"], ["7","1","3","9","2","4","8","5","6"], ["9","6","1","5","3","7","2","8","4"], ["2","8","7","4","1","9","6","3","5"], ["3","4","5","2","8","6","1","7","9"]] 解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
3.解法
🌵算法思路：
为了存储每个位置的元素，我们需要定义⼀个二维数组。首先，我们记录所有已知的数据，然后遍历所有需要处理的位置，并遍历数字 1~9。对于每个位置，我们检查该数字是否可以存放在该位置，同时检查行、列和九宫格是否唯一。
我们可以使用⼀个二维数组来记录每个数字在每⼀行中是否出现，⼀个二维数组来记录每个数字在每⼀列中是否出现。对于九宫格，我们可以以行和列除以 3 得到的商作为九宫格的坐标，并使用⼀个三维数组来记录每个数字在每⼀个九宫格中是否出现。在检查是否存在冲突时，只需检查行、列和九宫格里对应的数字是否已被标记。如果数字至少有一个位置（行、列、九宫格）被标记，则存在冲突，因此不能在该位置放置当前数字。
- 特别地，在本题中，我们需要直接修改给出的数组，因此在找到⼀种可行的方法时，应该停止递归，以防止正确的方法被覆盖。
初始化定义：
- 定义行、列、九宫格标记数组以及找到可行方法的标记变量，将它们初始化为 false。
- 定义⼀个数组来存储每个需要处理的位置。
- 将题目给出的所有元素的行、列以及九宫格坐标标记为 true。
- 将所有需要处理的位置存入数组。
递归函数设计：void dfs(vector<vector<char>>& board, int pos)
- 参数：pos（当前需要处理的坐标）；
- 返回值：无；
- 函数作用：在当前坐标填入合适数字，查找数独答案。
递归流程如下：
- 结束条件：已经处理完所有需要处理的元素。如果找到了可行的解决方案，则将标记变量更新为true 并返回。
- 获取当前需要处理的元素的行列值。
- 遍历数字 1~9。如果当前数字可以填入当前位置，并且标记变量未被赋值为 true，则将当前位置的行、列以及九宫格坐标标记为 true，将当前数字赋值给 board 数组中的相应位置元素，然后对下⼀个位置进行递归。
- 递归结束时，撤回标记。
🌵算法代码：
class Solution
{
bool row[9][10];
bool col[9][10];
bool box[3][3][10];
public:
void solveSudoku(vector<vector<char>>& board)
{
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (board[i][j] != '.')
{
int num = board[i][j] - '0';
row[i][num] = col[j][num] = box[i / 3][j / 3][num] = true;
}
}
}
dfs(board);
}
bool dfs(vector<vector<char>>& board)
{
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (board[i][j] == '.')
{
// 填数
for (int num = 1; num <= 9; num++)
{
if (!row[i][num] && !col[j][num] && !box[i / 3][j / 3][num])
{
board[i][j] = '0' + num;
row[i][num] = col[j][num] = box[i / 3][j / 3][num] = true;
if (dfs(board) == true) return true;
// 恢复现场
board[i][j] = '.';
row[i][num] = col[j][num] = box[i / 3][j / 3][num] = false;
}
}
return false;
}
}
}
return true;
}
};
扫一扫
1020
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
