回溯算法——好的开始

最新推荐文章于 2024-10-04 20:45:38 发布
最新推荐文章于 2024-10-04 20:45:38 发布
阅读量291 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法 leetcode 回归 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EGXXM/article/details/126906630
版权
0、前言和模板

前言：

第一次刷回溯算法，大概刷了8，9道

说真，起初以为上来就怼回溯会不会起点太高，后来，发现按照类型刷算法题真的会比一会一个二叉树一个贪心，一个动态好，毕竟会有一种拿捏感成就感

实践费曼学习法——咱先去理论学习了两个小时，基本在理论上拿捏了回溯，目前感觉回溯不就是个递归吗，只是给他增加了别的东西而已，最本质的就是递归

关于理论学习部分，看这个就够了回溯法，动态规划，贪心的区别

然后是一个好的刷题顺序，这部分我是从这个回溯刷题开始开始，有八道题，目前已经刷完,算是一个循序渐进的排序，包含了经典的子集问题，全排列问题等

当然了你可以直接看我的就行

下一个阶段打算跟着代码随想录的的刷题顺序刷题，但是不打算看他的长篇大论了

一点总结：

回溯算法，自上而下，遍历枚举每一种过程，从而判断是否满足

动态规划，自下而上，从已知的结果往上追溯，从而判断

贪心算法，这个根据经验做，比较难，是从局部最优得到整体最优结

请添加图片描述

回溯算法模板：

result = []
func backtrack(选择列表，路径)
	if 满足条件
		result.add(路径)
		return
  for 选择 in 选择列表
    做选择
    backtrack(选择列表，路径)
    撤销选择
1、子集问题

子集问题一：

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

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

func subsets(nums []int) [][]int {
    result := make([][]int, 0)
    list := make([]int, 0)
    backtrack(nums, 0, list, &result)
    return result
}
func backtrack(nums []int, pos int, list []int, result *[][]int){
    ans := make([]int,len(list))
    copy(ans,list)
    *result = append(*result,ans)
    for i := pos; i < len(nums); i++ {
        list = append(list,nums[i]) // 所谓选择就是树下走一步
        backtrack(nums, i+1, list, result) // 所谓处理就是对，backtrack函数里的值更新
        list = list[0 : len(list)-1] // 所谓撤销，就是使得中间list回到原来状态
    }
}

子集问题二：

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

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

func subsetsWithDup(nums []int) [][]int {
    result := make([][]int, 0)
    list := make([]int, 0)
    sort.Ints(nums) // 多了个排序，为了后续去重需要
    backtrack(nums,0,list,&result)
    return result
}
func backtrack(nums []int, pos int, list []int, result *[][]int){
    ans := make([]int, len(list))
    copy(ans,list)
    *result = append(*result, ans)
    for i := pos; i < len(nums); i++ {
        if i != pos && nums[i] == nums[i-1] { // 做到了去重，例如当pos为0时候，就不要1 2 2这个了，因为后边会再次出现一次。
            continue
        }
        list = append(list,nums[i])
        backtrack(nums,i+1,list,result)
        list = list[0 : len(list)-1]
    }
}
2、全排列问题

全排列问题一：

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

一定要带入实例，刚开始会绕的晕晕的，但是多晕几次，就会一次比一次清楚。

func permute(nums []int) [][]int {
    result := make([][]int, 0)
    list := make([]int, 0)
    visited := make([]bool, len(nums))
    backtrack(nums,visited,list,&result)
    return result
}
func backtrack(nums []int, visited []bool, list []int, result *[][]int){
    if len(list) == len(nums) {
        ans := make([]int, len(list))
        copy(ans,list)
        *result = append(*result, ans)
        return
    }
    
    for i := 0; i < len(nums); i++ {
        if visited[i] {
            continue
        }
            list = append(list, nums[i])
        visited[i] = true
        backtrack(nums, visited, list, result)
        visited[i] = false
        list = list[0 : len(list)-1]
    }
}

全排列问题二：

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

func permuteUnique(nums []int) [][]int {
    result := make([][]int, 0)
    list := make([]int, 0)
    visited := make([]bool, len(nums))
    sort.Ints(nums)
    backtrack(nums, visited, list, &result)
    return result
}
func backtrack(nums []int, visited []bool, list []int, result *[][]int){
    if len(list) == len(nums) {
        ans := make([]int, len(list))
        copy(ans,list)
        *result = append(*result,ans)
        return
    }
    for i := 0; i < len(nums); i++ {
        if visited[i] {  // 不要忘了，注意位置
            continue
        }
        if i != 0 && nums[i] == nums[i-1] && !visited[i-1] {   // 注意条件
            continue
        }
        list = append(list,nums[i])
        visited[i] = true
        backtrack(nums, visited, list, result)
        visited[i] = false
        list = list[0 : len(list)-1]
    }
}
3、提升

39. 组合总和

func combinationSum(candidates []int, target int) [][]int {
    result := make([][]int, 0)
    list := make([]int, 0)
    backtrack(0, 0, target, candidates, list, &result)
    return result
}
func backtrack(startIndex,sum,target int, candidates,list []int, result *[][]int){
    //目标_自下向上
    if sum  == target {
        ans := make([]int, len(list))
        copy(ans, list)
        *result = append(*result,ans)
        return
    }
    if sum > target {return}
    // 开始正主
    for i := startIndex; i < len(candidates); i++ {
        list = append(list, candidates[i])
        sum += candidates[i]
        backtrack(i, sum, target, candidates,list,result)
        list = list[0 : len(list)-1]
        sum -= candidates[i]
    }
}

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

func letterCombinations(digits string) []string {
    // 先把数字变成字母数组。
    length := len(digits)
    if length == 0{
        return nil
    }
    digitsMap := [10]string {
        "",     //0
        "",     //1
        "abc",  //2
        "def",  //3
        "ghi",  //4
        "jkl",  //5
        "mno",  //6
        "pqrs", //7
        "tuv",  //8
        "wxyz", //9
    }
    result := make([]string, 0)
    list := "" //中间暂存值
    backtrack(0, list, digits, digitsMap, &result)
    return result
}
func backtrack(Index int, list,digits string, digitsMap [10]string, result *[]string){
    // Index代表digits的当前下标
    if len(list) == len(digits) {
        // ans string
        // copy(ans, list)
        *result = append(*result, list)
        return
    }
    listK := digits[Index] - '0'
    dm := digitsMap[listK]
    for i := 0; i < len(dm); i++ {
        list = list + string(dm[i])
        backtrack(Index+1,list,digits,digitsMap,result) //index代表下一个选择
        list = list[ : len(list)-1]
    }
}

131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

func partition(s string) [][]string {
    //判断空
    // if len(s) == 0 {
    //     return nil
    // }
    // 判断条件变成了-是否回文
    result := make([][]string, 0)
    list := make([]string, 0)
    backtrack(0, s, list, &result)
    return result
}
//需要一个字符串变量
func backtrack(Index int, s string, list []string, result *[][]string){
    //结束条件看最后一个字符是否用了_出现最后一个字符
    if Index == len(s) {
        ans := make([]string, len(list))
        copy(ans, list)
        *result = append(*result, ans)
        //return
    }
    //选择列表是下一个字符,回文的方法是关键
    for i := Index; i < len(s); i++ {
        if huiwen(s,Index,i) {
            //是回文的话，就确定切割区间切割
            list = append(list,s[Index:i+1])
            backtrack(i+1,s,list,result) //记着，是i+1不是index+1
            list = list[:len(list)-1]
        }
    }
}
// 判断一个字符串是否为字符串,和我写的不一样
func huiwen(s string,Index,end int) bool {
    left := Index
    right := end
    for ; left < right; {
        if s[left] != s[right]{
            return false
        } 
        //移动左右指针
        left++
        right--
    }
    return true
}

93、复原 IP 地址

代码随想录的

func restoreIpAddresses(s string) []string {
	var res,path []string
	backTracking(s,path,0,&res)
	return res
}
func backTracking(s string,path []string,startIndex int,res *[]string){
	//终止条件
	if startIndex==len(s)&&len(path)==4{
		tmpIpString:=path[0]+"."+path[1]+"."+path[2]+"."+path[3]
		*res=append(*res,tmpIpString)
	}
	for i:=startIndex;i<len(s);i++{
		//处理
		path:=append(path,s[startIndex:i+1])
		if i-startIndex+1<=3&&len(path)<=4&&isNormalIp(s,startIndex,i){
			//递归
			backTracking(s,path,i+1,res)
		}else {//如果首尾超过了3个，或路径多余4个，或前导为0，或大于255，直接回退
			return
		}
        //回溯
		path=path[:len(path)-1]
	}
}
func isNormalIp(s string,startIndex,end int)bool{
	checkInt,_:=strconv.Atoi(s[startIndex:end+1])
	if end-startIndex+1>1&&s[startIndex]=='0'{//对于前导 0的IP（特别注意s[startIndex]=='0'的判断，不应该写成s[startIndex]==0，因为s截取出来不是数字）
		return false
	}
	if checkInt>255{
		return false
	}
	return true
}

第一次自己写，写成如下，感觉很接近了

func restoreIpAddresses(s string) []string {
    result := make([]string, 0)
    backtrack(0, 0, "", s, &result)
    return result
}
func backtrack(Index,ds int,list,s string, result *[]string) {
    if len(list) == len(s)+3 && ds == 3{ //结束条件，就是用了s的最后一个字符
        *result = append(*result, list)
    }
    //点数只能有三个
    for i := Index; i < len(s) && ds <= 3; i++ {
        //整数，没有前导0，没有其他符号,不能大于255，
        // 这个切割区间，前导不为零，继续下层bacetrack（特例子，只有一位数手，不算是前导）
        // 思考如何找到这个区间用于判断
        str := s[Index:i+1]
        s1, _ := strconv.Atoi(str)

        if s1 > 255 || s1 < 0{ // 有效区间是0~255，不满足的话直接跳过这个情况
            break
        }
        //前置不为零时候，长度是大于1的,当只有一个数是0的情况也满足
        if (str[0] != 0 && len(str) > 1) || len(str) == 1 { 
            list = list + str
            if len(list) < len(s)+3 && ds < 3{
                list += "."
                ds++
            }
            backtrack(i+1, ds, list, s, result)
            list = list[:len(list)-1] // 应该不只是len-1了
        }
    }
}
//果然，回溯法最难的还是，判断条件的难找啊

看过代码随想录的再去改正，发现及其相似了，唯独最关键的path就是我的list没有用[]string类型，导致越想越头疼。真可谓点睛之笔，但是为啥我就没想出来呢。

func restoreIpAddresses(s string) []string {
    list := make([]string, 0) // 作为路径，就是中间暂存值
    result := make([]string, 0)
    backtrack(0,list,s,&result)
    return result
}
func backtrack(Index int,list []string,s string, result *[]string) {
    if Index == len(s) && len(list) == 4{ //结束条件，就是用了s的最后一个字符 list长度只能为4
        ans := list[0] + "." + list[1] + "." + list[2] + "." + list[3]
        *result = append(*result, ans)
    }
    for i := Index; i < len(s); i++ {
        //前置不为零时候，长度是大于1的,当只有一个数是0的情况也满足
        list := append(list, s[Index:i+1])
        //数字截取的有效长度为3, list路径<=4个,正常IP,
        if i-Index+1 <= 3 && len(list) <= 4 && isIP(s,Index,i) { 
            backtrack(i+1, list, s, result)
        }else {
            //否则，这种不存在直接return这种结果，不必再执行for循环
            return
        }
        list = list[:len(list)-1]
    }
}
//判断ip条件,函数抽离
func isIP (s string, startIndex,end int) bool {
    str := s[startIndex:end+1]
    s1, _ := strconv.Atoi(str) //转化为数字了
    //当这个数，长度大于一位，前导不能为零，不能大于255
    if end - startIndex+1 > 1 && str[0] == '0' {
        return false
    }
    if s1 > 255 {
        return false
    }
    return true
}
不之道
关注
专栏目录
回溯算法——装载问题C语言
weixin_42159412的博客
04-05 5500
回溯算法——装载问题C语言 求解思路 输入: W = <w1+w2+···+wn>为集装箱重量c1和c2为船的最大载重量 算法思想 令第一艘船的装入量为W1。 用回溯算法求使得 c1-W1 达到最小的装载方案，即尽可能的使第一艘船装的更多； 若满足 w1+w2+···+wn -W1≤c2 则有解 ,否则无解； 若有解，其解的形式表示为一维向量x[n]，x[i]==1表示第i个集...
回溯算法——n后问题
06-10
回溯算法是一种在解决问题时，通过尝试所有可能的解决方案，并在发现不符合条件的解时能够及时终止当前路径，退回一步并尝试其他可能的路径的方法。它通常用于解决约束满足问题和搜索问题，如迷宫问题、八皇后问题、...
回溯算法理解-通过二叉树
Neo_L的博客
03-28 1211
建议参考：https://blog.csdn.net/sinat_27908213/article/details/80599460#commentBox 在此基础上，我建议以二叉树（不懂的先看二叉树）的思想来理解回溯算法。 回溯算法采用递归来实现，其实和遍历二叉树一样，只不过回溯算法通过约束条件进行裁剪截枝，最终根据约束条件而得到了自己想要的结果（解） 括号生成示例： /...
彻底搞懂回溯法（本文真的很详细）
热门推荐
阿华的保温杯的博客
03-20 6万+
目录 回溯法理论基础 组合问题 组合问题 转载于：https://zhuanlan.zhihu.com/p/302415065 回溯法理论基础 「回溯是递归的副产品，只要有递归就会有回溯」，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。 回溯法就是暴力搜索，并不是什么高效的算法，最多再剪枝一下。 回溯算法能解决如下问题： 组合问题：N个数里面按一定规则找出k个数的集合 排列问题：N个数按一定规则全排列，有几种排列方式 切割问题：一个字符串按一定规则
彻头彻尾的理解回溯算法
Walk More Slowly
04-12 2万+
定义 在程序设计中，有相当一类求一组解，或求全部解或求最优解的问题，例如读者熟悉的八皇后问题，不是根据某种特定的计算法则，而是利用试探和回溯的搜索技术求解。回溯法也是设计递归过程的一种重要方法，它的求解过程实质上是一个先序遍历一棵"状态树"的过程,只是这棵树不是遍历前预先建立的,而是隐含在遍历过程中。 ---《数据结构》(严蔚敏) 怎么理解这段话呢？ 首先，某种问题的解我们很难去找规律计算
回溯算法——全排列问题
m0_72379992的博客
10-22 1353
给出一个数组，返回所有可能的。其中“全排列”的定义如下：将n个元素按照一定的顺序排列起来，所有的排列情况的集合叫全排列。
回溯算法——n皇后问题
桑稚远方的博客
11-22 3569
盘上摆放n个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一对角线上，问有多少种摆法。我们可以思考，回溯算法，用最直白的话解释就是，当前这路不通，怎么办，回去，到上一个位置换个方向；，在一个集合中递归找子集，集合的大小就可以理解为需要递归的层；，不然就在函数体中出不来，会出错。、对于这三个规则，所以我们的核心层就应该，有两个判断（），就需要回溯到上一行皇后，更改上一行皇后的列。），就需要回溯到上一行皇后，更改上一行皇后的列。，那就结束呗，无路可走还继续呆着干嘛，哈哈哈哈；
回溯算法——全排列
Xiang_lhh的博客
11-10 2127
回溯算法框架 if 退出条件 { //将得到的值，保存到变量中 } for _ , 变量 := range 所有变量 { if 变量符合条件 { 将变量设为不符合条件，防止回溯之后重复选择 backtrace() //选择 将变量的不符合的释放，可以再次选择 } } 例题 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1]
回溯算法——LeetCode47 全排列 II
Beilin_LeBron的博客
08-15 190
【代码】回溯算法——LeetCode47 全排列 II。
回溯算法——LeetCode39 组合总和
Beilin_LeBron的博客
08-12 195
【代码】回溯算法——LeetCode39 组合总和。
回溯算法——LeetCode332 重新安排行程
Beilin_LeBron的博客
08-17 340
【代码】回溯算法——LeetCode332 重新安排行程。
五大常用算法——回溯算法详解及经典例题，算法数据结构 五大常用算法
04-07
回溯算法是一种常用的搜索算法，它可以用于解决许多复杂的问题。回溯算法的基本思想是，通过不断地尝试和回溯来找到问题的解。它可以看作蛮力法穷举搜索的改进，能够避免搜索所有可能的解，从而提高搜索效率。 在...
算法分析论文——回溯算法的应用.zip
10-19
总的来说，回溯算法是一种强大的通用求解工具，通过深入研究其原理和应用，我们可以更好地解决实际问题，特别是在面对复杂性和多样性的问题时。对于算法分析来说，理解回溯算法的时间和空间复杂性是至关重要的，这有...
【C++算法】9.双指针_四数之和
最新发布
hlyd520的博客
10-04 267
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1109
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
qq_64039411的博客
10-01 478
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1298
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 234
本文主要介绍按既定顺序创建目标数组问题
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 710
排序是将多个数据，依指定的顺序进行排列的过程。
C语言实现经典迷宫回溯算法详解
C语言重解经典回溯算法案例——迷宫问题是一种常见的编程挑战，它涉及到数据结构和算法设计中的回溯法应用。迷宫问题的核心是给定一个由0（可通行）和1（障碍）组成的二维矩阵，代表一个迷宫，以及两个坐标（入口和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不之道

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值