491.递增子序列
题目链接：491.递增子序列
文档讲解：代码随想录
状态：没做出来，原因是在used数组去重的用法不对，used数组是结合sort使用的，本题求自增子序列。
思路：局部去重 Set， 在每层递归调用中定义一个 Set，记录当前层级已经使用过的元素，避免重复使用。使用pre记录上次的值，确保不递减。
题解：
// 用于存储最终结果的列表
List<List<Integer>> res = new ArrayList<>();
// 用于存储当前路径的列表
LinkedList<Integer> list = new LinkedList<>();
/**
* 主方法，找到所有的非递减子序列
* @param nums 输入的数组
* @return 所有的非递减子序列
*/
public List<List<Integer>> findSubsequences(int[] nums) {
// 从索引0开始进行回溯，初始上一个元素值设为Integer.MIN_VALUE
backtracking(nums, 0, Integer.MIN_VALUE);
return res;
}
/**
* 回溯算法核心函数
* @param nums 输入的数组
* @param startIndex 当前起始索引
* @param pre 上一个元素的值
*/
public void backtracking(int[] nums, int startIndex, int pre) {
// 如果当前路径的长度大于等于2，将其添加到结果列表中
if (list.size() >= 2) {
res.add(new ArrayList<>(list));
}
// 使用HashSet来记录当前层级已经使用过的元素，防止同层级重复
Set<Integer> used = new HashSet<>();
// 从当前索引开始遍历数组
for (int i = startIndex; i < nums.length; i++) {
// 如果当前元素在本层级中已经使用过，则跳过该元素
if (used.contains(nums[i])) {
continue;
}
// 如果当前元素大于等于上一个元素，则将其添加到路径中
if (nums[i] >= pre) {
// 记录当前元素到HashSet，防止同层级重复使用
used.add(nums[i]);
// 将当前元素添加到路径中
list.add(nums[i]);
// 递归调用，继续向下层级探索，起始索引为i+1，更新上一个元素值为当前元素
backtracking(nums, i + 1, nums[i]);
// 回溯，移除路径中最后一个元素
list.removeLast();
}
}
}
46.全排列
题目链接：46.全排列
文档讲解：代码随想录
状态：没做出来，知道要去区分一个数字是否用过，但是没想起来使用used数组。
思路：使用used数组标记一个数字是否使用过。
题解：
// 用于存储最终结果的列表
List<List<Integer>> res = new ArrayList<>();
// 用于存储当前路径的列表
LinkedList<Integer> list = new LinkedList<>();
// 用于记录元素是否被使用的布尔数组
boolean[] used;
/**
* 主方法，找到所有的排列
* @param nums 输入的数组
* @return 所有的排列
*/
public List<List<Integer>> permute(int[] nums) {
// 对数组进行排序
Arrays.sort(nums);
// 初始化布尔数组，长度为输入数组的长度
used = new boolean[nums.length];
// 开始回溯算法
backtracking(nums);
return res;
}
/**
* 回溯算法核心函数
* @param nums 输入的数组
*/
public void backtracking(int[] nums) {
// 如果当前路径的长度等于数组的长度，将其添加到结果列表中
if (list.size() == nums.length) {
res.add(new ArrayList<>(list));
return;
}
// 遍历数组中的每个元素
for (int i = 0; i < nums.length; i++) {
// 如果当前元素未被使用
if (!used[i]) {
// 将当前元素添加到路径中
list.add(nums[i]);
// 标记当前元素为已使用
used[i] = true;
// 递归调用，继续向下层级探索
backtracking(nums);
// 回溯，移除路径中最后一个元素
used[i] = false;
list.removeLast();
}
}
}
47.全排列 II
思路：在上面一题的基础上加上利用used数组去重的操作。
题解：
// 用于存储最终结果的列表
List<List<Integer>> res = new ArrayList<>();
// 用于存储当前路径的列表
LinkedList<Integer> list = new LinkedList<>();
// 用于记录元素是否被使用的布尔数组
boolean[] used;
/**
* 主方法，找到所有的唯一排列
* @param nums 输入的数组
* @return 所有的唯一排列
*/
public List<List<Integer>> permuteUnique(int[] nums) {
// 对数组进行排序，方便后续去重
Arrays.sort(nums);
// 初始化布尔数组，长度为输入数组的长度
used = new boolean[nums.length];
// 开始回溯算法
backtracking(nums);
return res;
}
/**
* 回溯算法核心函数
* @param nums 输入的数组
*/
public void backtracking(int[] nums) {
// 如果当前路径的长度等于数组的长度，将其添加到结果列表中
if (list.size() == nums.length) {
res.add(new ArrayList<>(list));
return;
}
// 遍历数组中的每个元素
for (int i = 0; i < nums.length; i++) {
// 如果当前元素已被使用，或者当前元素与前一个元素相同且前一个元素未被使用过，跳过该元素
if (used[i] || (i > 0 && !used[i - 1] && nums[i - 1] == nums[i])) {
continue;
}
// 将当前元素添加到路径中
list.add(nums[i]);
// 标记当前元素为已使用
used[i] = true;
// 递归调用，继续向下层级探索
backtracking(nums);
// 回溯，移除路径中最后一个元素
used[i] = false;
list.removeLast();
}
}
332.重新安排行程
题目链接：332.重新安排行程
文档讲解：代码随想录
状态：不会，后面学图论再看
51.N皇后
步骤思路：
- 初始化棋盘
- 递归尝试在每一行放置皇后
- 检查放置是否有效
- 递归处理下一行或回溯
- 保存成功的棋盘配置
题解：
// 存储最终结果的列表
List<List<String>> res = new ArrayList<>();
// 存储当前棋盘配置的链表
LinkedList<String> list = new LinkedList<>();
// 解决N皇后问题的主函数
public List<List<String>> solveNQueens(int n) {
// 初始化棋盘，使用'.'表示空的单元格
char[][] board = new char[n][n];
for (char[] chars : board) {
Arrays.fill(chars, '.');
}
// 从第一行开始进行回溯
backtracking(board, 0);
return res;
}
// 回溯函数，用于在棋盘上放置皇后
public void backtracking(char[][] board, int row) {
// 如果所有行都已经处理完，将当前配置添加到结果中
if (row == board.length) {
res.add(new ArrayList<>(list));
return;
}
// 尝试在当前行的每一列放置皇后
for (int col = 0; col < board.length; col++) {
// 检查在 board[row][col] 放置皇后是否有效
if (isValid(board, row, col)) {
// 放置皇后
board[row][col] = 'Q';
// 将当前行的配置添加到链表中
list.add(new String(board[row]));
// 递归地在下一行放置皇后
backtracking(board, row + 1);
// 回溯，移除放置的皇后
list.removeLast();
board[row][col] = '.';
}
}
}
public boolean isValid(char[][] board, int row, int col) {
// 检查同一列是否有皇后
for (int i = 0; i < row; i++) {
if (board[i][col] == 'Q') return false;
}
// 检查左上方是否有皇后
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 'Q') return false;
}
// 检查右上方是否有皇后
for (int i = row - 1, j = col + 1; i >= 0 && j < board.length; i--, j++) {
if (board[i][j] == 'Q') return false;
}
return true;
}
37.解数独
题目链接：37.解数独
文档讲解：代码随想录
状态：没写出来，有思路，但是判断棋盘的代码没写出来。
思路：遍历整个数独棋盘，找到空格（即’.‘）。对于每一个空格，尝试填入数字’1’到’9’。每次填入一个数字后，检查该数字在当前行、列和3x3的小格子中是否有效。如果填入的数字有效，则递归调用函数继续填充下一个空格。如果递归调用成功（即找到一个有效的数独解），返回true，否则回溯（将当前数字移除，继续尝试下一个数字）。如果整个棋盘都填满了有效的数字，返回true，表示找到了一个解。如果所有数字都尝试完毕仍然无效，返回false。
题解：
// 主函数，解决数独问题
public void solveSudoku(char[][] board) {
backtracking(board);
}
// 回溯函数，尝试填充数独
public boolean backtracking(char[][] board) {
// 遍历每一行
for (int row = 0; row < 9; row++) {
// 遍历每一列
for (int col = 0; col < 9; col++) {
// 找到空格（即'.'）
if (board[row][col] == '.') {
// 尝试填入数字'1'到'9'
for (char num = '1'; num <= '9'; num++) {
// 检查填入的数字是否有效
if (isValid(board, row, col, num)) {
// 填入数字
board[row][col] = num;
// 递归尝试填充下一个空格
if (backtracking(board)) {
return true; // 找到有效的填充方案
}
// 回溯，如果后续填充不成功，撤销当前的填充
board[row][col] = '.';
}
}
return false; // 如果没有数字可以填入，返回false
}
}
}
return true; // 如果所有空格都填满，返回true
}
// 辅助函数，检查填入的数字是否有效
public boolean isValid(char[][] board, int row, int col, char num) {
// 检查行和列
for (int i = 0; i < 9; i++) {
if (board[row][i] == num || board[i][col] == num) {
return false;
}
}
// 检查3x3的小格子
// 先确定遍历的起始位置
int startRow = 3 * (row / 3);
int startCol = 3 * (col / 3);
for (int i = startRow; i < startRow + 3; i++) {
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == num) {
return false;
}
}
}
return true; // 如果行、列和小格子中都没有相同的数字，返回true
}
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
