【leetcode】回溯法

回溯法解决组合问题
与排序问题的区别：回溯法在组合问题中元素的顺序不用考虑，只需要从当前位置向后寻找。
排序问题每次都需要从头寻找，需要使用visited数组记录访问过的元素。

组合

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> ans = new LinkedList<>();
        if (k <= 0 || n < k) {
            return ans;
        }
        Deque<Integer> path = new ArrayDeque<>();
        dfs(n, k, 1, path, ans);
        return ans;
    }

    public void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> ans) {
        // 递归终止条件是：path 的长度等于 k
        if (path.size() == k) {
            ans.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i <= n; i++) {
             //向路径变量里添加一个数
            path.addLast(i);
            //下一轮搜索，设置的搜索起点要加 1，因为组合数里不允许出现重复的元素
            dfs(n, k, i + 1, path, ans);
           // 深度优先遍历有回头的过程，因此递归之前做了什么，递归之后需要做相同操作的逆向操作
            path.removeLast();

        }

    }
}

每一个结点递归地在做同样的事情，区别在于搜索起点，因此需要一个变量 start ，表示在区间 [begin, n] 里选出若干个数的组合；

全排列

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        int n=nums.length;
        List<List<Integer>> res=new LinkedList<>();
        if(n==0) return res;
        Deque<Integer> path=new ArrayDeque<>(n);
        boolean []visited=new boolean[n];
        dfs(nums,n,0,path,visited,res);
        return res;
    }
    private void dfs(int []nums, int n, int begin, Deque<Integer>path,boolean[]visited,List<List<Integer>>res){
        if(path.size()==n){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<n;i++){
            if(!visited[i]){
                path.addLast(nums[i]);
                visited[i]=true;
                dfs(nums,n,begin+1,path,visited,res);
                visited[i]=false;
                path.removeLast();
            }
        }
    }
}

字母大小写全排列

class Solution {
    public List<String> letterCasePermutation(String s) {
        List<String> res = new LinkedList<>();
        StringBuilder sb = new StringBuilder();
        dfs(s, 0, sb, res);
        return res;

    }

    public void dfs(String s, int begin, StringBuilder sb, List<String> res) {
        if (s.length() == sb.length()) {
            res.add(sb.toString());
            return;
        }
        for (int i = begin; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) {
                sb.append(c);
                dfs(s, i + 1, sb, res);
                sb.deleteCharAt(sb.length() - 1);
            } else {
                char A = Character.toUpperCase(c);
                sb.append(A);
                dfs(s, i + 1, sb, res);
                sb.deleteCharAt(sb.length() - 1);

                char a = Character.toLowerCase(c);
                sb.append(a);
                dfs(s, i + 1, sb, res);
                sb.deleteCharAt(sb.length() - 1);
            }

        }
    }

}

利用 StringBuilderStringBuilder 来进行字符串的拼接