【leetcode】回溯法

最新推荐文章于 2024-10-03 21:19:42 发布

Doyle_

最新推荐文章于 2024-10-03 21:19:42 发布

阅读量93

点赞数

本文链接：https://blog.csdn.net/doyle_/article/details/118730516

版权

LeetCode 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文讲解了回溯法在组合问题（如n选k）中的应用，通过Solution类展示了如何使用回溯法求解全排列，并特别关注了字母大小写全排列的实现。作者利用StringBuilder简化字符串操作，对比了回溯法与排序问题的区别。

摘要由CSDN通过智能技术生成

回溯法相关问题

回溯法解决组合问题
与排序问题的区别：回溯法在组合问题中元素的顺序不用考虑，只需要从当前位置向后寻找。
排序问题每次都需要从头寻找，需要使用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);
            }

        }
    }

}