回溯面试常考题

已于 2022-03-23 21:54:33 修改
阅读量188 收藏
点赞数
分类专栏： LeetCode 剑指Offer 文章标签： leetcode
于 2021-09-01 23:09:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45661125/article/details/120050022
版权
本文介绍了多个使用递归解决的算法问题，包括二叉树路径和、子集生成（考虑重复元素）、字符串排列、全排列（含重复元素）、加和目标值的组合以及数字字符串转IP地址等。这些算法均采用深度优先搜索（DFS）策略，通过回溯找到所有可能的解决方案。同时，还涵盖了组合问题，如无重复元素的组合总和和含有重复元素的集合。
摘要由CSDN通过智能技术生成

回溯

二叉树和为某一路径值

https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/

class Solution {
    List<List<Integer>> ret = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        if(root == null) {
            return ret;
        }
        dfs(root, target);
        return ret;
    }
    public void dfs(TreeNode root, int target) {
        if(root == null) {
            return ;
        }
        path.add(root.val);
        target -= root.val;
        if(target == 0 && root.left == null && root.right == null) {
            ret.add(new LinkedList(path));
        }
        dfs(root.left, target);
        dfs(root.right, target);
        path.removeLast();
    }
}

子集I（无重复元素，返回幂集）

https://leetcode-cn.com/problems/subsets/

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();
        ret.add(new ArrayList<>());
        for (int i = 0; i < nums.length; i++) {
           int size = ret.size();
            for (int j = 0; j < size; j++) {
                List<Integer> tmp = new ArrayList<>(ret.get(j));
                tmp.add(nums[i]);
                ret.add(tmp);
            }
        }
        return ret;
    }
}

子集II含义重复元素，返回幂集）

https://leetcode-cn.com/problems/subsets-ii/

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();
        ret.add(new ArrayList<>());
        if(nums == null || nums.length == 0) {
            return ret;
        }
        Arrays.sort(nums);
        List<Integer> list = new ArrayList<>();
        list.add(nums[0]);
        ret.add(list);
        if(nums.length == 1) {
            return ret;
        }
        int len = 1;
        for(int i = 1; i < nums.length; i++){
            int size = ret.size();
            if(nums[i] != nums[i-1]){
                len = size;
            }
            
            for(int j = size - len; j < size; j++){
                List<Integer> tmp = new ArrayList(ret.get(j));
                tmp.add(nums[i]);
                ret.add(tmp);
            }
        }
        return ret;
    }
}

字符串的排列

class Solution {
    List<String> ret = new ArrayList<>();
    public String[] permutation(String s) {
        if(s.length() == 0) {
            return new String[0];
        }
        int n = s.length();
        char[] str = s.toCharArray();
        Arrays.sort(str);
        StringBuffer path = new StringBuffer();
        boolean[] used = new boolean[n];
        dfs(str, n, 0, used, ret, path);
        return ret.toArray(new String[0]);
    }
    public void dfs(char[] str, int len, int depth, boolean[] used, List<String> ret, StringBuffer path ) {
        if(depth == len) {
            ret.add(path.toString());
        }
        for(int i = 0; i < len; i++) {
         if(used[i]) {
             continue;
         }
        
        if(i > 0 && str[i] == str[i - 1] && !used[i - 1]) {
            continue;
        }
        path.append(str[i]);
        used[i] = true;
        dfs(str, len, depth + 1, used, ret, path);
        used[i] = false;
        path.deleteCharAt(path.length() - 1);
         }
    }
}

没有重复数字的所有排列（全排列I）

https://leetcode-cn.com/problems/permutations/

class Solution {
    public List<List<Integer>> ret = new ArrayList<>();
    public List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permute(int[] nums) {
        if(nums == null || nums.length == 0) {
            return ret;
        }
        int n = nums.length;
        boolean[] used = new boolean[n];
        dfs(nums, n, 0, used, ret, path);
        return ret;
    }
    public void dfs(int[] nums, int len, int depth, boolean[] used, List<List<Integer>> ret,
    List<Integer> path) {
        if(depth == len) {
            ret.add(new ArrayList<>(path));
        }
        for(int i = 0; i < nums.length; i++) {
            if(!used[i]) {
                path.add(nums[i]);
                used[i] = true;
                dfs(nums, len, depth + 1, used, ret, path);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    } 
}

含有重复数字的所有排列（全排列II）

import java.util.*;

public class Solution {
    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
    ArrayList<Integer> path = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] nums) {
        if(nums == null || nums.length == 0) {
            return ret;
        }
        Arrays.sort(nums);
        int n = nums.length;
        boolean[] used = new boolean[n];
        dfs(nums, n, 0, used, ret, path);
        return ret;
    }
    public void dfs(int[] nums, int len, int depth, boolean[] used, ArrayList<ArrayList<Integer>> ret, ArrayList<Integer> path) {
        if(len == depth) {
            ret.add(new ArrayList<>(path));
        }
        for(int i = 0; i < nums.length; i++) {
           if(used[i]) {
               continue;
           }
            if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            dfs(nums, len, depth + 1, used, ret, path);
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }
}

加起来和为目标的值(一）(没有重复的元素）

https://www.nowcoder.com/questionTerminal/172e6420abf84c11840ed6b36a48f8cd

import java.util.*;
public class Solution {
    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> combinationCount (int target, int[] nums) {
        // write code here
        dfs(nums, 0, target, new ArrayList<Integer>());
        return ret;
    }
     
    private void dfs(int[] nums, int depth, int rest, ArrayList<Integer> path) {
        if(rest < 0){
            return;      // 凑过头了，直接返回
        }
        if(rest == 0){
            ret.add(new ArrayList<Integer>(path));     // 刚好凑到目标，返回一组结果
        }else{
            for(int i = depth; i < nums.length; i++){
                path.add(nums[i]);
                dfs(nums, i, rest - nums[i], path);
                path.remove(path.size() - 1);     // 回溯
            }
        }
    }
}

加起来和为目标的值(二）(有重复的元素）

https://www.nowcoder.com/practice/75e6cd5b85ab41c6a7c43359a74e869a?tpId=117&&tqId=37742&&companyId=139&rp=1&ru=/company/home/code/139&qru=/ta/job-code-high/question-ranking

import java.util.*;
public class Solution {
      
    ArrayList<ArrayList<Integer>> ret=new ArrayList<>();
    ArrayList<Integer> path = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> combinationSum2(int[] num, int target) {
        //首先排序
        Arrays.sort(num);
        dfs(num,0,target,path);
        return ret;
    }
     
    public void dfs(int []num,int index,int target,ArrayList<Integer> path){
        //我们这里做减法，当target为0 返回正确结果
        if(target == 0){
            ret.add(new ArrayList<>(path));
            return;
        }
        //这里进行循环
        for(int i = index; i < num.length; i++){
            //进行剪枝，当 num[i]>target的时候  肯定不能继续遍历
            if(target - num[i] < 0){
                break;
            }
            //当有相等元素时候，跳过，避免重复
            if(i > index && num[i] ==  num[i-1]){
                continue;
            }
            //代码到这里 已经是有效答案了
            path.add(num[i]);
            //继续进行递归， 注意这里下标不是  index+1   而是  i+1，
            dfs(num, i + 1, target - num[i], path);
            //回溯  这里要remove掉 
            path.remove(path.size()-1);
        }
    }
}

组合总和(允许重复选择元素的组合) 无重复元素，元素可以使用多次

https://leetcode-cn.com/problems/combination-sum/
给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。

class Solution {
    List<List<Integer>> res = new ArrayList<>(); //记录答案
    List<Integer> path = new ArrayList<>();  //记录路径

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        dfs(candidates, 0, target);
        return res;
    }
    public void dfs(int[] nums, int u, int target) {
        if(target < 0) return ;
        if(target == 0)
        {
            res.add(new ArrayList(path));
            return ;
        }
        for(int i = u; i < nums.length; i++){
            if( nums[i] <= target)  
            {
                path.add(nums[i]);
                dfs(nums, i, target -  nums[i]); // 因为可以重复使用，所以还是i
                path.remove(path.size() - 1); //回溯，恢复现场
            }
        }
    }
}

含有重复元素的集合（有重复元素，但只能使用一次）

https://leetcode-cn.com/problems/4sjJUc/

给定一个可能有重复数字的整数数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次，解集不能包含重复的组合。

class Solution {
    List<List<Integer>> ret=new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] nums, int target) {
      //首先排序
        Arrays.sort(nums);
        dfs(nums, 0, target, path);
        return ret;
    }
     
    public void dfs(int[] num, int index, int target, List<Integer> path){
        //我们这里做减法，当target为0 返回正确结果
        if(target == 0){
            ret.add(new ArrayList<>(path));
            return;
        }
        //这里进行循环
        for(int i = index; i < num.length; i++){
            //进行剪枝，当 num[i]>target的时候  肯定不能继续遍历
            if(target - num[i] < 0){
                break;
            }
            //当有相等元素时候，跳过，避免重复
            if(i > index && num[i] ==  num[i-1]){
                continue;
            }
            //代码到这里 已经是有效答案了
            path.add(num[i]);
            //继续进行递归， 注意这里下标不是  index+1   而是  i+1，
            dfs(num, i + 1, target - num[i], path);
            //回溯  这里要remove掉 
            path.remove(path.size()-1);
        }
    }
}

数字字符串转换成ip地址

https://www.nowcoder.com/practice/ce73540d47374dbe85b3125f57727e1e?tpId=117&&tqId=37725&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;


public class Solution {
    ArrayList<String> ret = new ArrayList<>();
    ArrayList<String> path = new ArrayList<>();
    public ArrayList<String> restoreIpAddresses (String s) {
        // write code here
        if(s.length() > 12 || s.length() < 4){
            return ret;
        }
        dfs(s, 0, ret, path);
        return ret;
    }
     private void dfs(String s, int depth, List<String> ret, List<String> path){
        int n = s.length();
        int size = path.size();
        if(3 * (4 - size) < n - depth || n - depth < (4 - size)){
            // 剩下的分不完了，剪枝
            return;
        }
        if(size == 4 && depth == n){
            // 正确的情况
            StringBuilder tmp = new StringBuilder();
            boolean first = true;
            for(String str : path){
                if(!first){
                    tmp.append(".");
                }
                first = false;
                tmp.append(str);
            }
            ret.add(tmp.toString());
            return;
        }
        // 如果是0需要特判
        if(s.charAt(depth) == '0'){
            path.add("0");
            dfs(s, depth + 1, ret, path);
            path.remove(path.size() - 1);
        }else{
            // 防止越界
            int right = Math.min(depth + 3, n);
            for(int i = depth; i < right; i++){
                String tmp = s.substring(depth, i + 1);
                if(check(tmp)){
                    path.add(tmp);
                    dfs(s, i + 1, ret, path);
                    path.remove(path.size() - 1);
                }
            }
        }
    }

    private boolean check(String s){
        int num = Integer.valueOf(s);
        return num <= 255 && num >= 0;
    }
}

组合

https://leetcode-cn.com/problems/combinations/
在这里插入图片描述

class Solution {
    List<List<Integer>> ret = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        if(k == 0) {
            return ret;
        }
        dfs(n, k, 1);
        return ret;
    }
    
    //1、递归函数的参数和返回值
    public void dfs(int n, int k, int depth){
        //2、递归终止条件
        if(path.size() == k){
            ret.add(new ArrayList<>(path));
            return;
        }
        //3、单层逻辑
        for (int i = depth; i <= n; i++) {
            path.add(i);
            dfs(n, k, i + 1);
            //回溯
            path.remove(path.size() - 1);
        }
    }
}

含有k个元素的组合

https://leetcode-cn.com/problems/uUsW3B/

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

  private void dfs(int num, int n, int k, List<Integer> path) {
    if (k == 0) {
      ret.add(new ArrayList<>(path));
      return;
    }
    for (int i = num; i <= n; i++) {
      path.add(i);
      dfs(i + 1, n, k - 1, path);
      path.remove(path.size() - 1);
    }
  }
}
赵jc
关注
专栏目录
面试必看算法题 | 回溯算法解题框架
weixin_49559515的博客
01-14 889
目录 1. 概述 1.1 回溯思想 回溯算法（Backtrack）是一种试错思想，本质上是深度优先搜索。即：从问题的某一种状态出发，依次尝试现有状态可以做出的选择从而进入下一个状态。递归这个过程，如果在某个状态无法做更多选择，或者已经找到目标答案时，则回退一步甚至多步重新尝试，直到最终所有选择都尝试过。 整个过程就像走迷宫一样，当我们遇到一个分叉口时，可以选择从一个方向进去尝试。如果走到死胡同则返回上一个分叉口，选择另外一条方向继续尝试，直到发现没有出口，或者找到出口。 1.2 回溯的三要素 理解了回.
面试总结------回溯问题
一只小包子的博客
02-25 479
回溯问题作为面试算法中经典问题之一，同时也是很容易总结出一套固定解题模板的算法类别，这里使用Leetcode中top-100 liked 为例，并尝试在解题过程中总结出对应的解题思路和解题模板 重点： 1.对于回溯问题最重要的一点就是在 foward—&gt;backtrack 这一过程状态的变化 例如从一个状态i 向前进行若干操作之后回溯到状态i 此时要把对应的其他改变的值恢复到状态i 2.对于...
回溯法数字全排列_经典面试题目「回溯算法」解数独
weixin_39928099的博客
11-28 199
解数独，理解二维递归是关键！通知：我将公众号文章和学习相关的资料整理到了Github ：https://github.com/youngyangyang04/leetcode-master，方便大家在电脑上学习，可以fork到自己仓库，顺便也给个star支持一波吧！37. 解数独题目地址：https://leetcode-cn.com/problems/sudoku-solver/编写一个程序，通...
组合总和（I和II）
I_Nice2cu的博客
08-22 257
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 注意：解集不能包含重复的组合。 示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 输出: [ [1,1,6], [1,2,5],[1,7], [2,6] ] 示例 2: 输入: candidates = [2,5,2,1,2], target = 5,.
面试中经常被问到的几个回溯问题
最新发布
小威的博客
11-29 2万+
本篇文章是对最近复刷的回溯相关的算法题进行记录，方便复习使用。如果文章有什么需要改进的地方还请大佬不吝赐教
阿里巴巴面试常考题解析：String、ArrayList与HashMap对比
10. 熟练使用至少一种版本控制系统，如Git，理解分支、合并、回溯等操作。 这些面试题目和相关知识点展示了阿里巴巴对技术人才的全面要求，不仅考察基础理论，还关注实际问题解决能力和对高效代码的追求。在准备...
关于算法面试的常考题
08-31
"关于算法面试的常考题"这个主题涵盖了面试过程中可能会遇到的各种算法问题，这些题目旨在测试候选人的逻辑思维、问题解决能力以及对数据结构和算法的深入理解。通过视频讲解的方式，学习者可以更直观地理解解题思路...
你不得不看的leetcode常考题（四月份每日一题）——Python版本
01-21
括号生成学习内容：回溯算法10号——151. 翻转字符串里的单词11号——887. 鸡蛋掉落12号——面试题 16.03. 交点13号——355. 设计推特14号——445. 两数相加 II15号——542. 01 矩阵16号——56. 合并区
在牛客网答题总结的前端面试71道HTML+CSS常考题
bluedandelion的博客
05-30 3997
1、浏览器页面有哪三层构成，分别是什么，作用是什么?       构成：结构层、表示层、行为层        分别是：HTML、CSS、JavaScript        作用：HTML实现页面结构，CSS完成页面的表现与风格，JavaScript实现一些客户端的功能与业务。2、HTML5的优点与缺点？优点：        a、网络标准统一、HTML5本身是由W3C推荐出来的；       b、多...
C/C++面试精华：算法挑战与公司考题
3. **字符串排列**：生成字符串的所有排列通常使用回溯法或DFS（深度优先搜索）实现，需要对字符串操作和递归有深入理解。 4. **自定义malloc函数**：理解内存分配原理，包括堆管理、内存对齐等，需要掌握C语言的...
回溯问题
abc_xian的博客
09-04 576
迷宫问题 题目：给一个二维列表，表示迷宫（0表示通道，1表示围墙）。给出算法，求一条走出迷宫的路径。 解决思路： 在一个迷宫节点(x,y)上，可以进行四个方向的探查：maze[x-1][y], maze[x+1][y], maze[x][y-1]...
强化面试中常用的算法 - 递归、回溯
qq_46038405的博客
11-14 451
强化面试中常用的算法 - 递归、回溯 目录 1 回顾 2 递归和回溯       2.1 递归 1 回顾       在上一个播客中，我总结了几种经典的排序算法，如果是在工作中，要对某个数组进行排序的话，我们直接利用函数库中的排序函数就好了，那么为什么在面试的时候还要考它们呢，原因就是面试主要考察是你分析问题和处理问题的能力，排序算法可以说是算法当中较为基础和简单的，但它们当中的一些思想还
面试过程中常见回溯套路总结
sym的博客
01-13 643
回溯算法概述 什么是回溯算法 回溯算法，又称为“试探法”、“穷举法”，是暴力算法的一种形式，也是一同通用的解题思路，按选优条件向前搜索，以达到目标。在解决问题时，每进行一步，都是抱着试试看的态度，如果发现当前选择非最优，或者按照当前路径走下去达不到目标，需要回退上一步的操作，重新进行下一轮选择。这种走不通就回退，再重新选择，直到遍历所有路径的方法就是回溯算法。 通俗地说，回溯法就是对每一个决策进行遍历的过程，可以理解为通过选择不同的树杈寻找到目标，一个树杈一个树杈地去尝试遍历。如果选择的当前路径不能达到目
数字轮盘最大值问题
Go的博客
10-18 2112
问题描述 轮盘游戏来自赌场，轮盘上面平均分成若干个小的扇形，每个扇形上都有一个数字，流传较广的轮盘数字布局有“欧式规则”和“美式规则”两种。当 2 &lt;= n &lt;= 36时，求连续 n 个数字的和最大值的数字排列情况，以及在求出轮盘连续 n 个数字最大值情况下，欧式轮盘规则下的和小于美式轮盘规则下的和的情况个数？ 欧式规则数字排列：0, 32, 15, 19, 4, 21, 2, 25,...
leetcode刷题记录16——组合总和
小白的学习路
01-13 223
难度：中等 给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。 candidates中的数字可以无限制重复被选取。 说明： 所有数字（包括target）都是正整数。 解集不能包含重复的组合。 示例1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ] 示例2： 输入：candidates = [2,3,5...
leetCode39题组合总和算法
qq1076472549的博客
12-20 251
题目： 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 示例 1: 输入: candidates = [2,3,5], target =...
C语言实现双轴快排—例题leetcode 912（手敲
克克克克业业的学习记录
11-24 1109
c语言实现双轴快排—例题leetcode912 之前拿冒泡插入写的时候忘记复杂度很高了，白写了 后来用希尔/快速排序等又实现了一遍，上一篇博客里附两种代码 看快速排序的时候就猜我们会考一下双轴快排，所以了解一下原理，手动敲了一遍，用leetcode排序数组验证了一下。 除了时间很长，空间占用还很大，估计没啥别的问题（可是我还优化了QAQ） 下面????开始讲思路： 对比单轴快速排序， 每次找到一个枢轴，大的放后边，小的放前边，直到left和right相遇，再将枢轴与中间值（就是代指枢轴那个数字应该呆的位置）
给定一个无重复元素的数组 candidates 和一个目标数 target .
m0_47575628的博客
11-18 2669
/* 给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。 candidates中的数字可以无限制重复被选取。 说明： 所有数字（包括target）都是正整数。 解集不能包含重复的组合。 示例1： 示例1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ] */ voidbackTrack(vect...
LeetCode刷题-十六进制魔术数字
纯洁的博客
10-28 352
前言说明 算法学习，日常刷题记录。 题目连接 十六进制魔术数字 题目内容 你有一个十进制数字，请按照此规则将它变成「十六进制魔术数字」：首先将它变成字母大写的十六进制字符串，然后将所有的数字0变成字母O，将数字1变成字母I。 如果一个数字在转换后只包含{“A”, “B”, “C”, “D”, “E”, “F”, “I”, “O”}，那么我们就认为这个转换是有效的。 给你一个字符串num，它表示一个十进制数N，如果它的十六进制魔术数字转换是有效的，请返回转换后的结果，否则返回"ERROR"。 示例1: 输入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值