LeetCode 回溯篇(46、77、78、51)
46. 全排列
给定一个 没有重复 数字的序列,返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
solution1
class Solution {
List<List<Integer>> res = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
LinkedList<Integer> track = new LinkedList<>();
backtrack(nums,track);
return res;
}
public void backtrack(int[] nums, LinkedList<Integer> track){
//满足结束条件
if (track.size() == nums.length){
res.add(new LinkedList(track));
return;
}
for (int i = 0; i < nums.length; i++){
if(track.contains(nums[i])) continue;
// 路径选择
track.add(nums[i]);
backtrack(nums,track);
// 撤销选择
track.removeLast();
}
}
}
//回溯模版 遍历一个回溯树
//result = []
// def backtrack(路径, 选择列表):
// if 满足结束条件:
// result.add(路径)
// return
// for 选择 in 选择列表:
// 做选择
// backtrack(路径, 选择列表)
// 撤销选择
77. 组合
给定两个整数 n 和 k,返回 1 ... n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
solution1
class Solution {
private List<List<Integer>> res = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
if (k <= 0 || n <= 0) return res;
backtrack(new LinkedList<>(),1, n, k);
return res;
}
public void backtrack(List<Integer> list, int l, int n, int k){
if (list.size() == k){
res.add(new LinkedList<Integer>(list));
}
for (int i = l; i <= n; i++){
list.add(i);
backtrack(list,i+1,n,k); //i+1,不是l+1,不然会重复出现[2,2]的情况
list.remove(list.size()-1);
}
}
}
78. 子集
给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。
说明:解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
思路
//递归与回溯(试错)
//思想:将大问题分解为小问题/分层 代码:先终止再 大问题分成小问题/当前层和下一层/不断试错
//1回溯 类似于组括号 nums有多少个就有多少层,每一层生成要加入还是不加两个情况
//2回溯 遍历nums,加入该数后进入该数下一位的挑选,到挑选最后一位跳出递归
//3迭代 n的子集=(n-1的子集)加上(n-1的子集和n的并集),代码由空和1开始不断迭代
solution 1 回溯1
class Solution {
public List<List<Integer>> subsets(int[] nums) {
ArrayList ans = new ArrayList();
if(nums == null) return ans;
dfs(ans,nums,new ArrayList<Integer>(),0);
return ans;
}
public void dfs(List<List<Integer>> ans,int[] nums,List<Integer> l,int index){
//终止条件
if (index == nums.length) {
ans.add(new ArrayList(l));// 引用的加入
return;
}
//大问题分成小问题/当前层和下一层/不断试错
dfs(ans,nums,l,index+1);
l.add(nums[index]);
dfs(ans,nums,l,index+1);
//清理当前层 (递归返回给上一层时必须保证list不变)
l.remove(l.size()-1);
}
}
solution2 回溯2
// 套用回溯模版
class Solution {
private List<List<Integer>> res = new ArrayList<>();
public List<List<Integer>> subsets(int[] nums) {
List<Integer> list = new LinkedList<>();
if (nums == null || nums.length == 0) return res;
backtrack(list,nums,0);
return res;
}
public void backtrack(List<Integer> list, int[] nums,int level){
res.add(new LinkedList<Integer>(list));
for(int i = level; i < nums.length; i++){
list.add(nums[i]);
backtrack(list,nums,i+1);//必须为i+1,i++先赋值再自增
list.remove(list.size()-1);
}
}
}
solution3 迭代
//时间复杂度为(N*(2^N))生成子集并复制到输出
class Solution {
public List<List<Integer>> subsets(int[] nums) {
List<List<Integer>> output = new ArrayList();
output.add(new ArrayList<Integer>());
for (int num:nums){
List<List<Integer>> newSubsets = new ArrayList();
for (List<Integer> curr:output) {
newSubsets.add(new ArrayList<Integer>(curr){{add(num);}}); //新建列表的同时加入对象
}
for (List<Integer> curr:newSubsets){
output.add(curr);
}
}
return output;
}
}
51. N皇后
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。
上图为 8 皇后问题的一种解法。
给定一个整数 n,返回所有不同的 n 皇后问题的解决方案。
每一种解法包含一个明确的 n 皇后问题的棋子放置方案,该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例:
输入: 4
输出: [
[".Q..", // 解法 1
"...Q",
"Q...",
"..Q."],
["..Q.", // 解法 2
"Q...",
"...Q",
".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。
提示:
皇后,是国际象棋中的棋子,意味着国王的妻子。皇后只做一件事,那就是“吃子”。当她遇见可以吃的棋子时,就迅速冲上去吃掉棋子。当然,她横、竖、斜都可走一到七步,可进可退。(引用自 百度百科 - 皇后 )
思路
//回溯1 先填满'.', 递归放q时,计算该点的对角线是否存在q,存在即回溯
//回溯1 对列、主次对角线的点保存起来,主对角线x+y相等,次对角线x-y相等
//hill 山丘 上升 主对角线
//dale 山谷 下降 次对角线
//List<String> curr = new ArrayList<>(Collections.nCopies(n,"...."));新建填满数的list<String>
//Arrays.fill(charArray, '.');新建填满数的char[]
solution1
class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> res = new ArrayList<>();
char[][] curr = new char[n][n];
for (int i =0;i<n;i++){
for(int j = 0;j<n;j++){
curr[i][j] = '.';
}
}
helper(res,curr,0,n);
return res;
}
public void helper(List<List<String>> res,char[][] curr,int col,int n){
if (col == n){
res.add(construt(curr));
return;
}
for(int row=0; row < n; row++){
if (isValid(curr,row,col,n)){
curr[row][col] = 'Q';
helper(res,curr,col+1,n);
curr[row][col] = '.';
}
}
}
public boolean isValid(char[][] curr,int row,int col,int n){
for (int i = 0;i<=col;i ++) {
if (curr[row][i] == 'Q') return false;
if (row-i>=0 && curr[row-i][col-i] == 'Q') return false;
if (row+i<n && curr[row+i][col-i] == 'Q') return false;
}
// for (int i = 0; i<n; i++){
// for(int j = 0;j < col; j++){
// if (curr[i][j] == 'Q' && (row+col == i+j || row-col == i-j || row==i))
// {return false;}
// }
// }
return true;
}
public List<String> construt(char[][] curr){
List<String> list = new ArrayList<>();
for (int i=0;i<curr.length;i++){
String s = new String(curr[i]);
list.add(s);
}
return list;
}
}
solution2 回溯
class Solution {
private Set<Integer> col = new HashSet<>();
private Set<Integer> hill = new HashSet<>();
private Set<Integer> dale = new HashSet<>();
public List<List<String>> solveNQueens(int n) {
List<List<String>> res = new ArrayList<>();
helper(res,new ArrayList<String>(),0,n);
return res;
}
public void helper(List<List<String>> res,List<String> curr,int y,int n){
if (y == n){
res.add(new ArrayList<>(curr));
return;
}
for (int x = 0;x<n;x++){
if (col.contains(x) || hill.contains(y+x) || dale.contains(x-y)) continue;
//确定行char转string
char[] charArray = new char[n];
Arrays.fill(charArray, '.');
charArray[x] = 'Q';
String str = new String(charArray);
curr.add(str);
//攻击距离
col.add(x);
hill.add(x+y);
dale.add(x-y);
//下一层
helper(res,curr,y+1,n);
//清理当前层(回溯)
curr.remove(curr.size()-1);
col.remove(x);
hill.remove(x+y);
dale.remove(x-y);
}
}
}
37. 解数独
编写一个程序,通过已填充的空格来解决数独问题。
一个数独的解法需遵循如下规则:
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
空白格用 '.' 表示。
Note:
给定的数独序列只包含数字 1-9 和字符 '.' 。
你可以假设给定的数独只有唯一解。
给定数独永远是 9x9 形式的。
solution1
class Solution {
public void solveSudoku(char[][] board) {
backtrack(board,0,0);
}
public boolean backtrack(char[][] board, int i, int j){
int m = 9, n = 9;
//换行
if (j == m){
return backtrack(board,i+1,0);
}
//base case
if (i == n){
return true;
}
// 已填数字
if (board[i][j] != '.'){
return backtrack(board,i,j+1);
}
for (char ch = '1'; ch <= '9'; ch ++){
// 不合法数字跳过
if(!isValid(board,i,j,ch)){
continue;
}
board[i][j] = ch;
if(backtrack(board,i,j+1)){
return true;
}
board[i][j] = '.';
}
return false;
}
public boolean isValid(char[][] board, int i,int j, char ch){
for (int p = 0;p < 9;p++){
if (board[p][j] == ch){
return false;
}
if (board[i][p] == ch){
return false;
}
if (board[(i/3)*3 + p/3][(j/3)*3 + p%3] == ch){
return false;
}
}
return true;
}
}