代码随想录算法训练营第25天 | 回溯问题完结

合集 - 代码随想录算法训练营(24)

1.代码随想录算法训练营第2天 | 数组滑动窗口、螺旋打印2024-07-042.代码随想录算法训练营第1天 | 数组二分法、数组双指针2024-07-033.代码随想录算法训练营第3天 | 链表删除元素、翻转链表2024-07-054.代码随想录算法训练营第4天 | 链表两两交换、删除倒N、链表相交、环形链表2024-07-065.代码随想录算法训练营第6天 | 哈希表的应用、复习快慢指针思想2024-07-086.代码随想录算法训练营第7天 | 哈希表和双指针结合、三数和四数之和2024-07-097.代码随想录算法训练营第8天 | 复习字符串API、双指针2024-07-108.代码随想录算法训练营第9天 | 复习字符串匹配、KMP2024-07-129.代码随想录算法训练营第10天 | 复习队列和栈2024-07-1210.代码随想录算法训练营第11天 | 复习逆波兰表达式求值2024-07-1411.代码随想录算法训练营第13天 | 复习二叉树基础2024-07-1512.代码随想录算法训练营第14天 | 复习二叉树翻转2024-07-1713.代码随想录算法训练营第15天 | 二叉树进阶2024-07-2114.代码随想录算法训练营第16天 | 二叉树更加进阶2024-07-2115.代码随想录算法训练营第17天 | 复习二叉搜索树2024-07-2216.代码随想录算法训练营第18天 | 二叉搜索树进阶2024-07-2317.代码随想录算法训练营第20天 | 二叉搜索树中级2024-07-2318.代码随想录算法训练营第21天 | 二叉搜索树结尾2024-07-2419.代码随想录算法训练营第22天 | 开始复习回溯2024-07-2420.代码随想录算法训练营第23天 | 回溯进阶2024-07-2721.代码随想录算法训练营第24天 | 复习组合问题2024-07-28

22.代码随想录算法训练营第25天 | 回溯问题完结2024-07-28

23.代码随想录算法训练营第27天 | 初入贪心2024-07-3024.代码随想录算法训练营第28天 | 贪心进阶2024-07-30

收起

2024年7月27日

题46. 全排列
继续回溯。

class Solution {

    List<List<Integer>> res;
    List<Integer> path;
    int[] used;
    int[] nums;

    public List<List<Integer>> permute(int[] nums) {
        //用一个used存
        //0表示还没有用，1表示用了
        res = new ArrayList<>();
        path = new LinkedList<>();
        this.nums = nums;
        used = new int[nums.length];
        backTracking(0);
        return res;
    }

    //index表示用了几个了
    public void backTracking(int index){
        if(index==nums.length){
            res.add(new ArrayList<>(path));
        }else{
            for(int i=0;i<nums.length;i++){
                if(used[i]==1){
                    continue;
                }else{
                    used[i]=1;
                    path.add(nums[i]);
                    backTracking(index+1);
                    used[i]=0;
                    path.removeLast();
                }
            }
        }
    }
}

题47. 全排列 II
继续使用简单包含方法判断去重，不过根据结果来看效率非常低效，后续需要学习一下标准做法。
凡是涉及重复元素的都要首先排序

class Solution {

    List<List<Integer>> res;
    List<Integer> path;
    int[] used;
    int[] nums;

    public List<List<Integer>> permuteUnique(int[] nums) {
        //用一个used存
        //0表示还没有用，1表示用了
        Arrays.sort(nums);
        res = new ArrayList<>();
        path = new LinkedList<>();
        this.nums = nums;
        used = new int[nums.length];
        backTracking(0);
        return res;
    }

    //index表示用了几个了
    public void backTracking(int index){
        if(index==nums.length){
            if(!res.contains(new ArrayList<>(path))){
                res.add(new ArrayList<>(path));
            }
        }else{
            for(int i=0;i<nums.length;i++){
                if(used[i]==1){
                    continue;
                }else{
                    used[i]=1;
                    path.add(nums[i]);
                    backTracking(index+1);
                    used[i]=0;
                    path.removeLast();
                }
            }
        }
    }
}

题51. N 皇后
重点是想明白怎么判断每条直线是否被占用。

class Solution {
    int[][] arr;
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        arr = new int[n][n];
        //第一个旗子只能在第一行
        for(int j=0;j<n;j++){
            arr[0][j] = 1;
            digui(1,n);
            arr[0][j] = 0;
        }
        return res;
    }

    public void digui(int index, int n){
        if(index==n){
            res.add(getList(n));
            return;
        }
        for(int j=0;j<n;j++){
            arr[index][j] = 1;
            if(!check(n)){
                arr[index][j] = 0;
            }else{
                digui(index+1,n);
                arr[index][j] = 0;
            }
        }
    }

    public boolean check(int n){
        //行一样
        //列一样
        //行列和一样
        //行列差一样
        int[][] bei = new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(arr[i][j]==1){
                    if(bei[i][j]==1){
                        return false;
                    }
                    //开始把线上的赋1
                    for(int p=0;p<n;p++){
                        bei[p][j] = 1;
                    }
                    for(int q=0;q<n;q++){
                        bei[i][q] = 1;
                    }
                    //把斜线赋1
                    int p=i,q=j;
                    while(p>=0&&q>=0){
                        bei[p][q]=1;
                        p-=1;
                        q-=1;
                    }
                    p=i;q=j;
                    while(p>=0&&q<n){
                        bei[p][q]=1;
                        p-=1;
                        q+=1;
                    }
                    p=i;q=j;
                    while(p<n&&q>=0){
                        bei[p][q]=1;
                        p+=1;
                        q-=1;
                    }
                    p=i;q=j;
                    while(p<n&&q<n){
                        bei[p][q]=1;
                        p+=1;
                        q+=1;
                    }
                }
            }
        }
        return true;
    }

    public List<String> getList(int n){
        List<String> res1 = new ArrayList<>();
        for(int i=0;i<n;i++){
            String s = "";
            for(int j=0;j<n;j++){
                if(arr[i][j]==1){
                    s+="Q";
                }else{
                    s+=".";
                }
            }
            res1.add(s);
        }
        return res1;
    }
}