leetcode回溯算法题

最新推荐文章于 2024-07-14 19:56:17 发布
最新推荐文章于 2024-07-14 19:56:17 发布
阅读量969 收藏 20
点赞数 19
文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74373359/article/details/136256567
版权
本文介绍了多个编程题目，包括全排列（无重复和有重复），子集生成，IP地址的合法恢复，非递减子序列查找，数独解法，N皇后问题以及行程重排。这些题目涉及到了回溯法、数组操作、字符串处理和搜索算法等技术。
摘要由CSDN通过智能技术生成

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        dfs(nums,new boolean[nums.length],new LinkedList<Integer>(),list);
        return list;
    }

    public void dfs(int[] nums , boolean[] isVisited , LinkedList<Integer> stack , List<List<Integer>> list){
        if(stack.size() == nums.length){
            list.add(new ArrayList(stack));
            return;
        }
        for(int i = 0 ; i < nums.length ; i++){
            if(!isVisited[i]){
                isVisited[i] = true;
                stack.push(nums[i]);
                dfs(nums , isVisited , stack , list);
                stack.pop();
                isVisited[i] = false;
            }
        }
    }
}

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        dfs(nums,new boolean[nums.length],new LinkedList<Integer>(),list);
        return list;
    }

        public void dfs(int[] nums , boolean[] isVisited , LinkedList<Integer> stack , List<List<Integer>> list){
        if(stack.size() == nums.length){
            list.add(new ArrayList(stack));
            return;
        }
        for(int i = 0 ; i < nums.length ; i++){
            if (i > 0 && nums[i] == nums[i - 1] && !isVisited[i-1]) {
                continue;
            }
            if(!isVisited[i]){
                isVisited[i] = true;
                stack.push(nums[i]);
                dfs(nums , isVisited , stack , list);
                stack.pop();
                isVisited[i] = false;
            }
        }
    }
}

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        res.add(new ArrayList<>());
        for(int i = 1; i <= nums.length;i++){
            res = getSub(0,new LinkedList<>(),nums,i,res);
        }
        return res;
    }
    private List<List<Integer>> getSub(int begin, LinkedList<Integer> list,int[] nums,int full,List<List<Integer>> res){
        if(list.size() == full){
            res.add(new ArrayList<>(list));
        }
        for(int i = begin; i < nums.length; i++){
            list.push(nums[i]);
            getSub(i+1,list,nums,full,res);
            list.pop();
        }
        return res;
    }
}

90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

class Solution {
    List<Integer> t = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        dfs(false, 0, nums);
        return ans;
    }

    public void dfs(boolean choosePre, int cur, int[] nums) {
        if (cur == nums.length) {
            ans.add(new ArrayList<Integer>(t));
            return;
        }
        dfs(false, cur + 1, nums);
        if (!choosePre && cur > 0 && nums[cur - 1] == nums[cur]) {
            return;
        }
        t.add(nums[cur]);
        dfs(true, cur + 1, nums);
        t.remove(t.size() - 1);
    }
}

93. 复原 IP 地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

  • 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

class Solution {
    public List<String> restoreIpAddresses(String s) {
        List<String> res = new ArrayList<>();
        char[] zArr = s.toCharArray();
        if (zArr.length < 4) return res;
        back(zArr, new LinkedList<>(),res);
        return res;
    }

    private void back(char[] zArr, LinkedList<Integer> list, List<String> res) {
        if (list.size() == 4) {
            if (list.peekLast() == zArr.length - 1) {
                StringBuilder curr = new StringBuilder();
                int index = 0;
                for (int i = 0; i < 4; i++) {
                    int num = list.get(i);
                    while (index <= num) {
                        curr.append(zArr[index++]);
                    }
                    if (i != 3) {
                        curr.append('.');
                    }
                }
                res.add(curr.toString());
            } else {
                return;
            }
        }
        if (list.isEmpty()) {
            if (zArr[0] == '0') {
                list.add(0);
                back(zArr, list, res);
                list.removeLast();
            } else {
                for (int i = 0; i < 3; i++) {
                    if (inRange(zArr, 0, i)) {
                        list.add(i);
                        back(zArr, list, res);
                        list.removeLast();
                    } else {
                        return;
                    }
                }
            }
        } else {
            int pre = list.peekLast();
            if (pre < zArr.length - 1) {
                int curr = pre + 1;
                if (zArr[curr] == '0') {
                    list.add(curr);
                    back(zArr, list, res);
                    list.removeLast();
                } else {
                    for (int i = curr; i < zArr.length; i++) {
                        if (!inRange(zArr, curr, i)) {
                            return;
                        } else {
                            list.add(i);
                            back(zArr, list, res);
                            list.removeLast();
                        }
                    }
                }
            }
        }
    }

    private boolean inRange(char[] zArr, int pre, int curr) {
        int jud = 0;
        while (pre <= curr) {
            jud *= 10;
            jud += (zArr[pre] - '0');
            pre++;
        }
        return jud >= 0 && jud <= 255;
    }
}

491. 非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<List<Integer>> container = new ArrayList<>();
        Map<List<Integer>, TreeSet<Integer>> map = new HashMap<>();
        TreeSet<Integer> set = new TreeSet<>();
        for (int num : nums) {
            int size = container.size();
            for (int i = 0; i < size; i++) {
                List<Integer> list = container.get(i);
                if (list.get(list.size() - 1) <= num) {
                    TreeSet<Integer> treeSet = map.get(list);
                    if (treeSet.add(num)) {
                        List<Integer> addList = new ArrayList<>(list);
                        addList.add(num);
                        container.add(addList);
                        map.put(addList, new TreeSet<>());
                    }
                }
            }
            if (set.add(num)) {
                ArrayList<Integer> list = new ArrayList<>(List.of(num));
                container.add(list);
                map.put(list, new TreeSet<>());
            }
        }
        for (List<Integer> list : container) {
            if (list.size() >= 2) res.add(list);
        }
        return res;
    }
}

37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

class Solution {
    public void solveSudoku(char[][] board) {
        boolean[][] row = new boolean[9][9];//行
        boolean[][] column = new boolean[9][9];//列
        boolean[][] block = new boolean[9][9];//块
        //填充数组
        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 9; j++){
                if(board[i][j]  != '.'){
                    int curr = (int)(board[i][j] - '1');
                    row[i][curr] = true;
                    column[j][curr] = true;
                    block[bloNums(i,j)][curr] = true;
                }
            }
        }
        dfs(board,0,0,row,column,block);
    }
    private boolean dfs(char[][] board, int i, int j, boolean[][] row, boolean[][] column, boolean[][] block){
        if(i >= 9)  return true;
        if(j >= 9){ return dfs(board,i+1,0,row,column,block);}
        if(board[i][j] != '.'){return dfs(board,i,j+1,row,column,block);}

        for(int curr = 0; curr < 9; curr++){
            if(!row[i][curr] && !column[j][curr] && !block[bloNums(i,j)][curr]){
                board[i][j] = (char)(curr+'1');
                row[i][curr] = true;
                column[j][curr] = true;
                block[bloNums(i,j)][curr] = true;
                if(dfs(board,i,j+1,row,column,block)){
                    return true;
                }
                board[i][j] = '.';
                row[i][curr] = false;
                column[j][curr] = false;
                block[bloNums(i,j)][curr] = false;
            }
        }
        return false;
    }
    private int bloNums(int row, int column){
        return row/3*3 + column/3;
    }
}

51. N 皇后

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

class Solution {
   public List<List<String>> solveNQueens(int n) {
        List<List<String>> res = new ArrayList<>();
        char[][] chs = new char[n][n];
        for (char[] ch : chs) {
            Arrays.fill(ch, '.');
        }
        boolean[] column = new boolean[n];//列
        boolean[] left = new boolean[2 * n - 1];//左斜线 - /   i+j
        boolean[] right = new boolean[2 * n - 1];//右斜线 - \  n-1-(i-j)

        dfs(chs,0,column,left,right,res);
        return res;
    }

    static void dfs(char[][] chs, int i, boolean[] column, boolean[] left, boolean[] right, List<List<String>> res) {
        if (i == chs.length){
            List<String> list = new ArrayList<>();
            for (char[] ch : chs) {
                list.add(new String(ch));
            }
            res.add(list);
            return;
        }

        for (int j = 0; j < chs.length; j++) {
            if (column[j] || left[i + j] || right[chs.length + j - i - 1]) continue;


            chs[i][j] = 'Q';
            column[j] = left[i + j] = right[chs.length + j - i - 1] = true;
            dfs(chs, i + 1, column, left, right, res);
            chs[i][j] = '.';
            column[j] = left[i + j] = right[chs.length + j - i - 1] = false;
        }

    }
}

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

  • 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

class Solution {
    boolean over = false;
    List<String> res = new ArrayList<>();

    public List<String> findItinerary(List<List<String>> tickets) {
        Map<String, TreeMap<String, Integer>> map = new HashMap<>();
        int sum = tickets.size();

        for (List<String> ticket : tickets) {
            String from = ticket.get(0);
            String to = ticket.get(1);
            if (map.get(from) == null) {
                TreeMap<String, Integer> treeMap = new TreeMap<>();
                treeMap.put(to, 1);
                map.put(from, treeMap);
            } else {
                TreeMap<String, Integer> treeMap = map.get(from);
                treeMap.merge(to, 1, Integer::sum);
            }
        }
        res.add("JFK");
        dfs("JFK",sum,map);
        return res;
    }

    private void dfs(String from, int sum, Map<String, TreeMap<String, Integer>> map) {
        if (sum == 0) {
            over = true;
            return;
        }
        TreeMap<String, Integer> treeMap = map.get(from);
        if(treeMap == null || treeMap.isEmpty()) return;
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            if (value > 0) {
                value--;
                treeMap.put(key,value);
                res.add(key);
                dfs(key, sum - 1, map);
                if(over){
                    return;
                }
                res.remove(res.size() - 1);
                value++;
                treeMap.put(key,value);
            }
        }
    }
}

βetta
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LeetCode回溯算法
xylitolz的博客
03-05 483
文章目录回溯算法 vs 深度优先遍历回溯算法 vs 动态规划共同点不同点LeetCode 22. 括号生成题目回溯LeetCode 39. 组合总和题目回溯LeetCode 46. 全排列题目回溯Reference 回溯算法 vs 深度优先遍历 维基百科中「回溯算法」和「深度优先遍历」的定义: 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题
leetcode 回溯算法总结（python）
weixin_42723548的博客
02-11 1695
回溯使用的场景： 回溯法非常适合由多个步骤组成的问题，并且每个步骤都有多个选项，当我们在某一步选择了其中一个选项时，就进入下一步，然后又面临新的选项。我们就这样重复选择着，直至到达最后的状态。 一般画树状图表示 做回溯的题步骤：【树的深度遍历过程】 画图，观察元素是否有重复，如有重复则需要剪枝，思考如何剪枝 回溯三要素：路径、选择列表、结束条件 按照此代码模板，写出代码。 【https...
回溯算法小结（leetcode回溯题集合）
qq_36309684的博客
10-24 469
回溯算法小结 回溯法定义 回溯法：采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 上面说到回溯法在试错的过程中，会取消上一步或者几步的操作，从而开始进行其它的尝试。这时候的这个过程，
leetcode回溯问题总结 Python
BIT_Legend的博客
01-02 1074
每次分割都可以看做一个选择，所以本问题依然是不定数量的选择问题，所以本问题用回溯来实现分割，但与之前回溯不一样的是，本问题在调用回溯函数时，需要完成两个数值的选择，之前的应用都是仅仅完成一个数值的选择(其实本质上没有区别)。该问题看起来与有重复元素的子集问题极为相似，都是遍历的每个路径都需要保存，都是包含重复元素，都是需要去除重复子集，但是实际解法有些不同，原因是该问题不能首先排序，因为排序会打乱原有的顺序，而本问题需要提取非递减序列。回溯算法是在递归思想的基础上制定的算法框架，用于解决一类问题。
图解 LeetCode 算法汇总——回溯
qq_42700121的博客
09-11 781
回溯算法尝试在问题的解空间中搜索可能的解，并在搜索过程中进行选择、撤销选择和终止搜索，直到找到解或确定无解为止。通常通过递归函数来实现回溯算法。在每一步，需要做出选择（选择一个分支）然后递归地探索该选择的结果。在递归返回后，需要撤销之前的选择，以便继续探索其他分支。使用条件语句或循环来控制选择的范围和条件。
leetcode回溯算法总结（一）
HarryXu的博客
03-31 238
  这几天学了一下回溯算法，也看了一些题目，总结下就是以后遇到需要枚举，然后结果可能就是两种分支的时候，考虑一下是不是适合用回溯法 给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……， 25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。 输入: 12258 输出: 5 解...
leetcode回溯算法经典例题——单词搜索
weixin_72076848的博客
08-02 658
LeetCode回溯算法经典例题——单词搜索
Leetcode学习之回溯算法
frighting_ing的博客
11-14 4467
1. 回溯算法理论基础 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以回溯函数也就是递归函数，指的都是一个函数。 回溯法的效率 回溯法的性能如何呢，必须强调的是，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，**如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回
leetcode回溯算法系列(排列组合篇)
weixin_72076848的博客
07-31 285
LeetCode回溯算法系列(排列组合篇)
【回溯】leetcode回溯算法
zjkstudy
03-03 233
回溯算法介绍 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。回溯法可以理解成递归的一种特殊形式。 最...
leetcode初级算法.zip
10-23
《LeetCode初级算法C++详解》 LeetCode作为全球知名的在线编程挑战平台，深受程序员喜爱，尤其是对于初学者，它提供了丰富的算法题目，是提升编程技能和算法理解的绝佳场所。本资料集“leetcode初级算法.zip”正是...
leetcode:算法题
03-30
《LeetCode：算法题与Java实战》 在编程领域，LeetCode是一个广为人知的在线平台，它提供了大量的算法题目，旨在帮助开发者提升算法技能，准备面试，以及深入理解数据结构与算法。LeetCode主要涉及的编程语言之一是...
LeetCode:LeetCode算法题
05-11
在这个“LeetCode算法题”资源中，我们重点关注Java语言的实现。 在LeetCode上，你可以找到各种难度级别的问题，从基础到高级，涵盖排序、搜索、图论、动态规划、回溯法等众多算法。通过解决这些题目，Java开发者...
LeetCode高频算法面试题,含解题思路及代码实现
02-17
以上是LeetCode高频算法面试题的一些主要知识点。通过深入学习和实践，你可以提升自己的算法能力，为面试做好充分准备。解题思路和代码实现的分享可以帮助你更好地理解和应用这些算法，从而在实际工作中解决复杂的...
leetcode:刷算法题
03-21
《LeetCode：刷算法题全攻略》 在编程领域，LeetCode是一个广受欢迎的在线平台，它提供了大量的算法题目供开发者练习和提升自己的编程技能。本文将深入探讨LeetCode及其在提升算法和数据结构能力方面的重要性，特别...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 438
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 203
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 397
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 217
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
LeetCode算法与数据结构解析：路径求和与祖先节点查找
"该资源是关于数据结构和算法的学习资料，包含了LeetCode算法题的解题实践以及数据结构与算法的书籍中部分算法的实现。其中，提供的代码示例涉及到了二叉树的路径和祖先节点查找问题，具有详细的注释以帮助理解。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值