ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

回溯算法经典问题总结(.NET版)

2022-09-14 16:32:00  阅读:263  来源: 互联网

标签:int sum List new 算法 candidates 回溯 path NET


回溯算法

回溯法其实也是一种递归,本质上就是穷举,然后筛选出符合规则的数据。为了使回溯更加高效,我们根据规则要求,在穷举过程中加上条件限制(也就是剪枝)。

我们什么场景下应该想到使用回溯法呢?

如何画图去分析问题?

如何使用代码实现呢?

如何去优化程序?

回溯算法经典问题(使用场景)

  • 组合问题:N个数⾥⾯按给定规则找出k个数的集合
  • 切割问题:⼀个字符串按⼀定规则有⼏种切割⽅式
  • ⼦集问题:⼀个N个数的集合⾥有多少符合条件的⼦集
  • 排列问题:N个数按⼀定规则全排列,有⼏种排列⽅式
  • 棋盘问题:N皇后,解数独等等

组合是不强调元素顺序的,排列是强调元素顺序

画图分析回溯

面对回溯问题,我们第一想法就是画图!所有回溯法的问题都可以抽象为树形结构!

回溯法⼀般是在集合中递归搜索,集合的⼤⼩构成了树的宽度,递归的深度构成的树的深度。

回溯法模板

public void Backtracking(参数)
{
   if(满足终止条件)
     {
          存放结果
          return;
     }
    for(遍历本层集合中的元素)
    {
        处理结点;
        dfs(参数);//递归
        撤销处理该结点; //回溯
     }
}

看下面几个例子加深理解。

组合问题

77.组合

题目:给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。

示例 1:
输入:n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

第一步:画图

我们已经知道组合是不考虑顺序的,[1,2],[2,1] 是一样的。所以我们在取数的时候,只需要取当前下标及后边下标即可。横向就是给定的n,纵向就是给定的k。按照示例n=4,k=2画出树状图如下:

第二步:解题思路及模板的使用

//1.确定返回结果
IList<IList<int>> res = new List<IList<int>>();//存放符合条件的结果集合
List<int> path = new List<int>();//存放符合条件的结果
//2.确定入参
// * 题目给定的集合需要进入函数(此处是n,也可以是数组等集合)
// * 需要知道终结条件,本题为k
// * 题目要求返回组合,不考虑顺序,所以需要一个变量来记录当前选取n位置
//3.确定回溯方法
// startIndex用来记录本层递归的中,集合从哪里开始遍历
public void Backtracking(int n,int k,int startIndex)
{
   //4.终止条件
   if(path.Count==k)
     {
          //存放结果
          res.Add(new List<int>(path));
          return;
     }
    for(int i=startIndex;i<=n;i++)
    {
        path.Add(i);//处理节点
        Backtracking(n,i+1);//递归
        path.Remove(path.Count-1);//撤销处理该结点; 回溯
     }
}

第三步:优化剪枝

按照上边,收集叶子节点就可以写出程序了。我们如何优化程序,如何实现剪枝呢?比如n=4,k=4,按照上图所示,会进入很多次不必要的分支。我们应该剪掉。当剩余节点不能够满足条件时,就不必继续进行了。如下图所示:

最终:完整代码

        IList<IList<int>> res = new List<IList<int>>();
        IList<int> path = new List<int>();
        public IList<IList<int>> Combine(int n, int k)
        {
            BackTracking(n, k, 1);
            return res;
        }
        public void BackTracking(int n, int k, int startIndex)
        {
            if (path.Count == k)
            {
                res.Add(new List<int>(path));
                return;
            }
            // n - (k - path.Count) + 1
            //剪枝。如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了,那么就没有必要搜索了。
            for (int i = startIndex; i <= n - (k - path.Count) + 1; i++)
            {
                path.Add(i);
                BackTracking(n, k, i + 1);
                path.RemoveAt(path.Count - 1);
            }
        }

40.组合总和 II

题目:给定一个候选人编号的集合 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意:解集不能包含重复的组合。
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

第一步:画图

不包含重复的组合

例如当 {candidates} = [2, 2],{target} = 2时,上述算法会将列表 [2][2] 放入答案两次。

我们可以用一个Hash,咱.NET中使用Dictionary,将每次出现的元素和频率记录下来。不过更方便的是我们将candidates排序,查看是否和上一个元素相同。

第二步:套模板

        private IList<IList<int>> result = new List<IList<int>>();//结果集
        private List<int> path = new List<int>();//结果
        int sum;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="candidates">元素数组</param>
        /// <param name="startIndex">开始下标</param>
        /// <param name="isUsed">记录是否使用</param>
        /// <param name="target">条件</param>
        public void BackTracking(int[] candidates, int startIndex, bool[] isUsed, int target)
        {
            if (sum == target) //终止条件
            {
                result.Add(new List<int>(path));//收集结果
                return;
            }
            for (int i = startIndex; i < candidates.Length && candidates[i] + sum <= target; i++)
            {
                //出现重复节点,同层的第一个节点已经被访问过,所以直接跳过
                if (i > 0 && candidates[i] == candidates[i - 1] && !isUsed[i - 1])
                {
                    continue;
                }
                isUsed[i] = true;
                sum += candidates[i];
                path.Add(candidates[i]);
                //每个节点仅能选择一次,所以从下一位开始
                BackTracking(candidates, i + 1, isUsed, target);
                int temp = path[path.Count - 1];
                path.Remove(path[path.Count - 1]);
                isUsed[i] = false;
                sum -= temp;
            }

        }

第三步:剪枝优化

  1. 如果选取的元素,和已经大于目标值就没必要继续进行了。

candidates[i] + sum <= target

  1. 如果同层相同元素已经使用过,可以剪掉。不理解可以Debug跟一下,或者看着图想一下。

if (i > 0 && candidates[i] == candidates[i - 1] && !isUsed[i - 1])

最终:完整代码

        private IList<IList<int>> result=new List<IList<int>>();
        private IList<int> path=new List<int>();
        int sum;
        public IList<IList<int>> CombinationSum2(int[] candidates, int target)
        {
            Array.Sort(candidates);
            bool[] used = new bool[candidates.Length];
            BackTracking(candidates, 0, used, target);
            return result;
        }
        public void BackTracking(int[] candidates, int index, bool[] used, int target)
        {
            if (sum == target)
            {
                result.Add(new List<int>(path));
                return;
            }

            for (int i = index; i < candidates.Length && candidates[i]+sum<=target; i++)
            { 
                //出现重复节点,同层的第一个节点已经被访问过,所以直接跳过
                if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1])
                {
                    continue;
                }
                used[i] = true;
                sum += candidates[i];
                path.Add(candidates[i]);
                //每个节点仅能选择一次,所以从下一位开始
                BackTracking(candidates, i+1, used, target);
                int temp = path[path.Count - 1];
                path.Remove(path[path.Count-1]);
                used[i] = false;
                sum -= temp;
            }

        }

216.组合总和 III

题目:找出所有相加之和为 n 的 k 个数的组合,且满足下列条件:
只使用数字1到9
每个数字 最多使用一次 
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次,组合可以以任何顺序返回。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7

第一步:画图

其实这道题和第一题差不多,就是收集结果时加了一个和的限制。

第二步:套模板

        IList<IList<int>> res = new List<IList<int>>();
        IList<int> path = new List<int>();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="targetSum">给定目标和</param>
        /// <param name="k">要求元素个数</param>
        /// <param name="startIndex">开始下标</param>
        /// <param name="sum">当前已选取元素和</param>
        public void BackTracking(int targetSum, int k, int startIndex, int sum)
        {
            // 减枝
            if (sum > targetSum)
            {
                return;
            }
            if (path.Count == k)
            {
                if (targetSum == sum)
                    res.Add(new List<int>(path));
                return;
            }
            // 减枝 9 - (k - path.size()) + 1
            for (int i = startIndex; i <= 9 - (k - path.Count) + 1; i++)
            {
                path.Add(i);
                sum += i;
                BackTracking(targetSum, k, i + 1, sum);
                //回溯
                path.RemoveAt(path.Count - 1);
                //回溯
                sum -= i;
            }
        }

第三步:剪枝优化

  1. 选取元素小于等于目标和
  2. 剩余元素个数满足条件k

最终:完整代码

        IList<IList<int>> res = new List<IList<int>>();
        IList<int> path = new List<int>();
        public IList<IList<int>> CombinationSum3(int k, int n)
        {
            BackTracking(n, k, 1, 0);
            return res;
        }
        public void BackTracking(int targetSum, int k, int startIndex, int sum)
        {
            // 减枝
            if (sum > targetSum)
            {
                return;
            }
            if (path.Count == k)
            {
                if (targetSum == sum)
                    res.Add(new List<int>(path));
                return;
            }
            // 减枝 9 - (k - path.size()) + 1
            for (int i = startIndex; i <= 9 - (k - path.Count) + 1; i++)
            {
                path.Add(i);
                sum += i;
                BackTracking(targetSum, k, i + 1, sum);
                //回溯
                path.RemoveAt(path.Count - 1);
                //回溯
                sum -= i;
            }
        }

注意点

  1. 组合是无序的,所以需要strartIndex来控制选择范围,查找当前结果时,不可以再次使用。当然如果选取元素不是同一集合,就不要用startIndex了。比如17. 电话号码的字母组合

  2. 题目给的元素集合,是否存在重复元素,如果存在,需要对同层相同已使用元素进行剪枝

  3. 结果长度是否有要求?如果有要求判断剩余元素是否满足长度要求。

切割问题

⼦集问题

排列问题

棋盘问题

类似问题

洪水算法 flood fill

第一步:画图

第二步:套模板

第三步:剪枝优化

最终:完整代码

标签:int,sum,List,new,算法,candidates,回溯,path,NET
来源: https://www.cnblogs.com/Z7TS/p/16649625.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[[email protected]]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有