回溯法刷题——组合

题目一：77.组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
解法：回溯法，主要有三点；返回条件，收集结果，处理结点，递归，回溯；
下面的方法主要是从头开始取，比如先取1,加入节点中，后面递归除了1剩下的数，（递归中找和1搭配的组合），回溯到下一循环（在除了1剩下数字中可以组成的k个数的组合）

class Solution {
    List<Integer> path = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);
        return ans;
    }
    void backtracking(int n, int k, int start){
        if(path.size() + (n - start + 1) < k){
            return;
        }//重要，判断后续的数字还满不满足答案的长度；这个代码没有这个也可运行
        if(path.size() == k){
            ans.add(new ArrayList<Integer>(path));//收集答案
            return;
        }
        for(int i = start; i <= n; i++){//第一次循环（1234）第二次（234）
            path.add(i);//如果取1
            backtracking(n, k, i + 1);//除了1后面k-1个数
            path.remove(path.size() - 1);
        }
    }
}

class Solution {
    List<Integer> temp = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    public List<List<Integer>> combine(int n, int k) {
        dfs(1, n, k);
        return ans;
    }

    public void dfs(int cur, int n, int k) {
        // 剪枝：temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
        if (temp.size() + (n - cur + 1) < k) {
            return;
        }//必须加上
        // 记录合法的答案
        if (temp.size() == k) {
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        // 考虑选择当前位置
        temp.add(cur);
        dfs(cur + 1, n, k);
        temp.remove(temp.size() - 1);
        // 考虑不选择当前位置
        dfs(cur + 1, n, k);
    }
}

问题二：电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射与电话按键相同。注意 1 不对应任何字母。
解法：

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> ans = new ArrayList<String>();
        if(digits.length() == 0){//
            return ans;
        }
        Map<Character, String> Phone = new HashMap<Character, String>(){{
            put('2', "abc");
            put('3', "def");
            put('4', "ghi");
            put('5', "jkl");
            put('6', "mno");
            put('7', "pqrs");
            put('8', "tuv");
            put('9', "wxyz");
        }};//如何加入数字，重要
        backtracking(ans, Phone, digits, 0,new StringBuffer());//
        return ans;
    }
    void backtracking(List<String> ans, Map<Character, String> Phone, String digits, int k, StringBuffer str){//BufferString?
        if(k == digits.length()){
            ans.add(str.toString());
            return;
        }
        char digit = digits.charAt(k);//
        String letters = Phone.get(digit);
        int count = letters.length();// char[] ch = b.toCharArray();法二
        for(int i = 0; i < count; i++){//i < ch.length;法二
             str.append(letters.charAt(i));// str.append(ch[i]);法二
             backtracking(ans, Phone, digits, k+1, str);
             str.deleteCharAt(k);//
        }
    }
}

自己动手重难点：String和StringBuffer的用法
HashMap的常用操作
题目三：22.括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

class Solution {
    List<String> ans = new ArrayList<String>();
    //ArrayList<String> str = new ArrayList<>();表示二
    public List<String> generateParenthesis(int n) {
        if(n == 0) return ans;
        backtracking(new StringBuffer(), 0, 0, n);
        return ans;
    }
    void backtracking(StringBuffer str, int left, int right, int n){//
        if(str.length() == n*2){
            ans.add(str.toString());// ans.add(String.join("", str));表示二
            return;
        }
        if(left < n){//
            str.append('(');
            backtracking(str, left + 1, right, n);//不能是left++ 或者++left；1、加上（之后加（
            str.deleteCharAt(str.length() - 1);//str.remove(str.size() - 1);表示二
        }
        if(right < left){//1、加上（之后加）
            str.append(')');
            backtracking(str, left, right + 1, n);//
            str.deleteCharAt(str.length() - 1);
        }
    }
}

题目四：39、组合生成
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。（也可以用target-candidate[i], 判断无效target<0 , 有效target=0）

class Solution {
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    List<Integer> path = new ArrayList<Integer>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if(candidates.length == 0){
            return ans;
        }
        backtracking(candidates, target, 0, 0);
        return ans;
    }
    void backtracking(int[] candidates, int target, int sum, int start){//要加入开始搜索的位置
        if(sum > target){//重要，不然死循环，排除不合理答案
            return;
        }
        if(sum == target){
            ans.add(new ArrayList<>(path));//
            return;
        }
        for(int i = start; i < candidates.length; i++){
        //if(pathsum + candidates[i]<=target)判断无效
            path.add(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i);//可以重复所以是i而不是i+1
            path.remove(path.size() - 1);//
            sum -= candidates[i];
        }  
    }
}

题目五：40、组合总和2
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用 一次 。

class Solution {
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    List<Integer> path = new ArrayList<Integer>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        if(candidates.length == 0){
            return ans;
        }
        Arrays.sort(candidates);//先排序
        backtracking(candidates, target, 0);
        return ans;
    }
    void backtracking(int[] candidates, int target, int start){
        if(target == 0){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i = start; i < candidates.length; i++){
            if(target - candidates[i] < 0){
                break;
            }
            if(i > start && candidates[i] == candidates[i - 1]){
                continue;//避免重复数组
            }
            path.add(candidates[i]);
            backtracking(candidates, target - candidates[i], i+1);
            path.remove(path.size() - 1);
        }
    }
}

题目六：37、解数独
解法：spaces中存放的是未填入数字的位置，先把填入数字的位置标记上，和放入未填位置的信息；用回溯法从1开始试；

class Solution {
    boolean[][] a = new boolean[9][9];
    boolean[][] b = new boolean[9][9];
    boolean[][][] c = new boolean[3][3][9];
    List<int[]> spaces = new ArrayList<int[]>();
    boolean valid = false;
    public void solveSudoku(char[][] board) {
       for(int i = 0; i < 9; i++){
           for(int j = 0; j < 9; j++){
               char ch = board[i][j];
               if(ch == '.'){
                   spaces.add(new int[]{i, j});//要加new
               }else{
                   int digit = board[i][j] - '0' - 1;
                   a[i][digit] = b[j][digit] = c[i/3][j/3][digit] = true;//输入字符转变为数字
               }
           }
       }
       backtracking(board, 0);
    }
    void backtracking(char[][] board, int pos){
        if(pos == spaces.size()){
            valid = true;
            return;
        }
        int[] space = spaces.get(pos);
        int i = space[0], j = space[1];
        for(int con = 0; con < 9 && !valid; con++){//加上判断是否已经找到答案，找到就不用再回溯
            if(!a[i][con] && !b[j][con] && !c[i/3][j/3][con]){
                board[i][j] = (char)(con + '0' + 1);//数字转为字符
                a[i][con] = b[j][con] = c[i/3][j/3][con] = true;
                backtracking(board, pos + 1);
                a[i][con] = b[j][con] = c[i/3][j/3][con] = false;
            }
        }
    }
}