Leetcode回溯法
回溯法简介
回溯法是复杂度很高的暴力搜索算法，实现简单且有固定模板，常被用于搜索排列组合问题的所有可行解。不同于普通的暴力搜索，回溯法会在每一步判断状态是否合法，而不是等到状态全部生成后再进行确认。当某一步状态非法时，它将回退到上一步中正确的位置，然后继续搜索。前进和后退是回溯法关键的动作。
回溯的本质就是暴力枚举所有可能。要注意的是，由于回溯通常结果集都记录在回溯树的路径上，因此如果不进行撤销操作， 则可能在回溯后状态不正确导致结果有差异， 因此需要在递归到底部往上冒泡的时候进行撤销状态。
如果你每次递归的过程都拷贝了一份数据，那么就不需要撤销状态，相对地空间复杂度会有所增加
算法流程
构造空间树。
进行遍历。
如遇到边界条件，即不再向下搜索，转而搜索另一条链。
达到目标条件，输出结果。
伪代码
const visited = {}
function dfs(i) {
if (满足特定条件）{
// 返回结果 or 退出搜索空间
}
visited[i] = true // 将当前状态标为已搜索
dosomething(i) // 对i做一些操作
for (根据i能到达的下个状态j) {
if (!visited[j]) { // 如果状态j没有被搜索过
dfs(j)
}
}
undo(i) // 恢复i
}39 组合总和
题目描述
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
示例：
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
下述代码的解释：
第二个dfs是通过超过数组个数则停止向右移动
不管是第一个dfs还是第二个dfs，两者生长都是在同一个节点上向下或者右下。
代码
import java.util.ArrayList;
import java.util.List;
public class L16 {
public static void main(String[] args) {
Solution solution=new Solution();
int[] candidates= {2,3,6,7};
solution.combinationSum(candidates,7);
System.out.println(solution.ans);
}
}
class Solution {
List<List<Integer>> ans = new ArrayList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
dfs(candidates, 0, target, new ArrayList<>());
return ans;
}
//idx表示当前位置，cur表示当前路径的某个信息，path表示路径，ans表示结果集 cur和path都是从出发点到当前位置的路径上的某个信息。
public void dfs(int[] candidates, int idx, int cur, List<Integer> path) {
// 递归结束
if (cur == 0) { //cur表示我还需要寻找剩余的差额 如果为0 说明不缺了 那么成功
// 克隆 path 并添加到 ans 成功后 path为我过来的路径 将它加入到全局变量中
ans.add(new ArrayList<>(path));
System.out.println(path);
return;
} else if (idx == candidates.length) { //idx当前位置已经到了数组的末尾，idx从0开始的，因此如果idx等于长度后说明已经超过了界限 数组已经遍历完了
return;
}
// 1.加入这个数字
if (candidates[idx] <= cur) { // 当前位置的元素比目标值小 那么将其容纳进来
path.add(candidates[idx]); //路径加上这个元素
// idx 不变，继续考虑当前数字
dfs(candidates, idx, cur - candidates[idx], path); //路径值不变 继续考虑当前元素 如果从这里返回了说明进行了剪枝 此路不通
// 消除影响
path.remove(path.size() - 1); //把上面增加的元素删除，这个元素用不了
}
// 2.不加入这个数字，考虑下一个数字 到这里说明上面元素要么递归不行回来了，要么比目标值小
dfs(candidates, idx + 1, cur, path);
}
}40 组合总数
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
思路
数组中每个数字只能使用一次
数组中可能存在数字
去除重复组合办法
class Solution {
List<List<Integer>> ans = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
dfs(candidates, 0, target);
return ans;
}
public void dfs(int[] candidates, int idx, int cur) {
if (cur == 0) {
ans.add(new ArrayList<>(path));
return;
} else if (idx == candidates.length) {
return;
}
// 当前数字与前面数字相同并且前面数字没有在路径中，则忽略这个数字
if (idx != 0 && candidates[idx] == candidates[idx - 1] && !visited.contains(idx - 1)) {
dfs(candidates, idx + 1, cur);
return;
}
// 1.加入这个数字
if (candidates[idx] <= cur) {
path.add(candidates[idx]);
visited.add(idx);
// 向下递归时考虑下一个数字
dfs(candidates, idx + 1, cur - candidates[idx]);
// 消除影响
path.remove(path.size() - 1);
visited.remove(idx);
}
// 2.不加入这个数字
dfs(candidates, idx + 1, cur);
}
}78 子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例：
输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
class Solution {
List<List<Integer>> ans = new ArrayList<>();
public List<List<Integer>> subsets(int[] nums) {
dfs(nums, 0, new ArrayList<>());
return ans;
}
public void dfs(int[] nums, int idx, List<Integer> path) {
if (idx == nums.length) {
ans.add(new ArrayList<>(path));
return;
}
path.add(nums[idx]);
dfs(nums, idx + 1, path);
path.remove(path.size() - 1);
dfs(nums, idx + 1, path);
}
}
46 全排列
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案
输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class L16_4 {
public static void main(String[] args) {
Solution4 solution=new Solution4();
int[] candidates= {1,2,3};
solution.permute(candidates);
// System.out.println(solution.ans);
}
}
class Solution4 {
List<List<Integer>> ans = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
// List<Integer> path = new ArrayList<>();
public List<List<Integer>> permute(int[] nums) {
dfs(nums, 0, new ArrayList<>());
return ans;
}
public void dfs(int[] nums, int idx, List<Integer> path) {
int i=0;
if (idx == nums.length) {
System.out.println(path);
ans.add(new ArrayList<>(path));
return;
}
while(i<nums.length)
{
while(visited.contains(i)) i++;
if(i<nums.length) {
visited.add(i);
path.add(nums[i]);
dfs(nums, idx + 1, path);
visited.remove(i);
path.remove(path.size() - 1);
i++;
}
}
}
}增加代码简洁文章，本代码为第一个例子代码简洁化_贪睡的蜗牛的博客-CSDN博客
37 解数独
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。
visted表示
关于思路，上面全排列是有不能重复的限制，这里有三个限制
下面代码有点问题，dfs是标准答案，dfs2是我想把所有答案打印出来，有问题。
public class L16_5 {
public static void main(String[] args) {
Solution5 solution=new Solution5();
int[] candidates= {2,3,6,7};
char [][]board = new char[][]{{'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'}};
// solution.dfs2();
// System.out.println((char)5);
solution.solveSudoku(board);
// for(int i=0;i<9;i++)
// {
// for (int j=0;j<9;j++)
// System.out.print(board[i][j]);
// System.out.println();
// }
}
}
class Solution5 {
boolean[][] col = new boolean[9][9];
boolean[][] row = new boolean[9][9];
boolean[][] place = new boolean[9][9];
public void solveSudoku(char[][] board) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (board[i][j] == '.') {
continue;
}
int num = board[i][j] - '1';
row[i][num] = true;
col[j][num] = true;
place[i / 3 * 3 + j / 3][num] = true;
}
}
char[][]path=new char[9][9];
dfs2(board,path,col,row,place,0,0);
//dfs(board, 0, 0);
}
public boolean dfs(char[][] board, int i, int j) {
if (j == 9) {
return dfs(board, i + 1, 0);
} else if (i == 9) {
return true;
} else if (board[i][j] != '.') {
return dfs(board, i, j + 1);
}
for (int k = 0; k < 9; k++) {
if (col[j][k] || row[i][k] || place[i / 3 * 3 + j / 3][k]) {
continue;
}
board[i][j] = (char)('1' + k);
col[j][k] = true;
row[i][k] = true;
place[i / 3 * 3 + j / 3][k] = true;
if (dfs(board, i, j + 1)) {
return true;
}
board[i][j] = '.';
col[j][k] = false;
row[i][k] = false;
place[i / 3 * 3 + j / 3][k] = false;
}
return false;
}
//i 表示的是行数，j表示的是列数
public void dfs2(char [][]abroad,char[][]path,boolean[][] col,boolean[][] row,boolean[][] place,int i,int j)
{
System.out.println("--------------------------------");
do{
if (i==9)
{
System.out.println("最后一步");
for(int i2=0;i2<9;i2++)
{
for (int j2=0;j2<9;j2++)
System.out.print(path[i2][j2]);
System.out.println();
}
return;
}else if (j==9) //说明列到达边界
{
// dfs2(abroad,path,col,row,place,i+1,0);
i+=1;
j=0;
System.out.println("进入，i的值为"+i);
}// 下面暂时保留
while (abroad[i][j]!='.')
{
j++;
}
}while (i==9||j==9||abroad[i][j]=='.');
//col表示列，row代表行，place代表九宫格，path代表历史记录
for(int k=0;k<9;k++) {
if (col[j][k]||row[i][k]||place[i/3*3+j/3][k])
{
//如果已经存在这个数了 那么进行下一个
continue;
}
else{
//如果不存在这个数
int n2=k+1;
char n1 =(char) (n2+'0');
abroad[i][j]=(char)n1;
System.out.println("改变第"+i+"行"+"第"+j+"列，值为 "+abroad[i][j]);
path[i][j]=(char)n1;
col[j][k]=true;
row[i][k]=true;
place[i/3*3+j/3][k]=true;
dfs2(abroad,path,col,row,place,i,j+1);
//消除影响
abroad[i][j]='.';
path[i][j]='.';
col[j][k]=false;
row[i][k]=false;
place[i/3*3+j/3][k]=false;
}
System.out.print(i);
System.out.println(j);
}
return;
}
}