leedcode-回溯

全排列

 List<List<Integer>> ans = new ArrayList<>();
  
 public List<List<Integer>> permutation(int[] nums){
  
	  List<Integer> track = new ArrayList<>();
	  backtrack(nums, track);
  
	  return ans;
 }
 public void backtrack(int[] nums, List<Integer> track) {
  
	  if(track.size() == nums.length) {
		   ans.add(new ArrayList<>(track));
		   return;
	  }
	  
	  for(int num : nums) {
		   if(track.contains(num)) {
			    continue;
		   }
		   track.add(num);
		   backtrack(nums, track);
		   track.remove(track.size() - 1);
	  }
  
 }

1. N 皇后（leedcode-51）

• 在全排列基础上进行修改（从第一行逐层添加）
• isValid()：分别对该列，右上角，左上角进行判断

2. 数独（leedcode-37）

• 填充一个二维数组，当填充完毕时需中断递归（board[row][col] = '.'不能执行），将返回值改为 boolean（还有一个作用是，找到一组符合条件即可中断）
• board[row/3 * 3 + i / 3][col/3 * 3 + i % 3] == c：判断当前所在的九宫格中是否有相同的字符

3. 括号生成（leedcode-22）

• 填充括号：open < n：填充左括号；close < open：填充右括号
• backtrack(n, left + 1, right, track)：不能用++left，因为这样会修改left值，影响后面right的取值

子集（leedcode-78）

• 问题描述：输入一个不包含重复数字的数组，要求输出这些数字的所有子集

   List<List<Integer>> ans = new ArrayList<>();
   public List<List<Integer>> subsets(int[] nums) {
   
            List<Integer> track = new ArrayList<>();
             backtrack(nums, 0, track);
     
             return ans;
    }
    public void backtrack(int[] nums, int start, List<Integer> track) {
     
	     ans.add(new ArrayList<>(track));
     	     // 不同于全排列，这里从 start 下标开始
	     for(int i = start; i < nums.length; i++) {
		      track.add(nums[i]);
		      backtrack(nums, i + 1, track);
		      track.remove(track.size() - 1);
	     }
    }     

组合（leedcode-77）

• 问题描述：给定两个整数 n 和 k，返回 1…n 中所有可能的 k 个数的组合

    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
	     List<Integer> track = new ArrayList<>();
	     // 从 1 开始， 这里并不是代表下标，而是数字
	     backtrack(n, k, 1, track);
	     return ans;
    }         
    public void backtrack(int n, int k, int start, List<Integer> track) {
     
	     if(track.size() == k) {
		      ans.add(new ArrayList<>(track));
		      return;
	     }
     
	     // 从 1 开始
	     for(int i = start; i <= n; i++) {
		      track.add(i);
		      backtrack(n, k, i + 1, track);
		      track.remove(track.size() - 1);
	     }
     
    }