超详细的回溯算法

一.回溯算法的定义

        回溯算法实际上常被用来暴力搜索解决问题，通过不断回溯上一步来罗列出所有的可能性并在此基础上选择出正确的答案

二.算法模板(伪代码)

void backtracking()
{
    if(结果的判断)
    {
        存储结果
        return;
    }

    
    for()
        遍历本层元素；
        path.push_back()处理本层元素
        backtracking()//递归到下一层
        path.pop_back()//回溯
}

三.题目类型

1)组合问题

        [leetcode]77.组合

        题目描述

        给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

        

 

class Solution {
public:
    vector>result;
    vectorpath;


    void backtracking(int n,int k,int startindex)
    {
        if(path.size() == k)
        {
            result.push_back(path);
            return ; 
        }


        for(int i = startindex;i <= n ;++i)
        {
            path.push_back(i);
            backtracking(n,k,i+1);
            path.pop_back();
        }
    }
    vector> combine(int n, int k) 
    {
        backtracking(n,k,1);
        return result;
    }
};

        [leetcode]216

        [leetcode]17

        [leetcode]39

        [leetcod]40

        均为组合问题

2)截取问题

        [leetcode]131.分割回文串

        给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

 

class Solution {
public:
    vector>result;
    vectorpath;

    bool judge(string s,int begin,int end)
    {
        if(begin == end)
        return true;
        if(begin > end)
        return false;
        while(begin < end)
        {
            if(s[begin] != s[end])
            {
                return false;
            }
            begin++;
            end--;
        }
        return true;
    }

    void backtracking(string s,int startindex)
    {
        if(startindex >= s.size())
        {
            result.push_back(path);
            return;
        }


        for(int i = startindex;i < s.size();++i)
        {
            if(judge(s,startindex,i))
            {
                string str = s.substr(startindex,i - startindex + 1);
                path.push_back(str);
            }
            else
            {
                continue;
            }


            backtracking(s,i + 1);
            path.pop_back();
        }
    }
    vector> partition(string s) 
    {
        backtracking(s,0);
        return result;
    }
};

        [leetcode]93

3)子集问题

        [leetcode]78.子集

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

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

class Solution {
public:
    vector>result;
    vectorpath;

    void backtracking(vector nums,int startindex)
    {
        result.push_back(path);
        if(startindex >= nums.size())
        {
            return;
        }


        for(int i = startindex;i < nums.size();++i)
        {
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }     
    vector> subsets(vector& nums) 
    {
        backtracking(nums,0);
        return result;
    }
};

         [leetcode]93

4)排列问题

        [leetcode]46

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

       

class Solution {
public:
    vector>result;
    vectorpath;
    bool judge = true;


    void backtracking(vectornums, int startindex)
    {
        if (path.size() == nums.size())
        {
            int pointer1 = 0;
            int pointer2 = 1;
            for(int i = 0;i < path.size();++i)
            {
                for(int j = i + 1;j < path.size();++j)
                {
                    if(path[i] == path[j])
                    {
                        judge = false;
                        break;
                    }
                }
            }
            if (judge == true)
                result.push_back(path);
            judge = true;
            return;
        }



        for (int i = 0; i < nums.size(); ++i)
        {
            path.push_back(nums[i]);
            backtracking(nums, i);
            path.pop_back();
        }
    }
    vector> permute(vector& nums)
    {
        //回溯算法
        backtracking(nums, 0);
        return result;
    }
};

         [leetcode]47