回溯算法总结 分割篇

分割问题 是对一个序列进行切分的过程，切分出的符合的序列则放入结果集

因为是对同一个序列操作，所以肯定是需要一个startindex来保证不重复。 那么如何切分一个序列呢， 在for循环中，我们将i的初始值设置为 startindex , 然后让i往后走， [startindex , i] 作为一个切分的序列，每切分一个序列要判断是否符合回文串的规则，若符合，则放入path集中，进入下一层递归，递归时使 startindex 为 i+1 ,从当前分割末尾的下一个位置继续分割。
当 startindex 比序列长度大的时候，代表已经找到一种分割方法了。

class Solution {
public:
    vector<vector<string>> result;
    vector<string> substr;
    bool ishuiwen(const string &s,int start ,int end)
    {   
        
        int left = start;
        int right = end;
        while(left <= right)
        {
            if(s[left] != s[right]) return false;
            left ++;
            right --;
        }
        return true;
    }
    void backtracking(string s ,int startindex ) //开始切割的下标
    {
        if(startindex >= s.size())
        {
            result.push_back(substr);
            return;
        }
        // startindex 作为切割的起点， i作为切割的终点
        for(int i = startindex ; i< s.size();i++)
        {
            if(ishuiwen(s,startindex,i))
            {   
                string str = s.substr(startindex,i-startindex+1 );
                substr.push_back(str);
            }else{
                continue;
            }
            // 树枝下去的下一次切割从i+1开始
            backtracking(s,i+1);
            substr.pop_back();
        }

    }
    vector<vector<string>> partition(string s) {
        backtracking(s,0);
        return result;
    }
};

复原ip地址
给定一个字符串，给出所有合法的ip地址的切分方法

这里的. 相当于是切割的地方，所以也就是将一个字符串切割成四段，其中每段都满足ip地址需要满足的性质。
题目中给出了切割的标识为.
切割为四段的时候，那么.号为3，这也就标识了已经成功切割出一个符合条件的ip地址了。

这里注意递归时 切割起始点 startindex 应为 i+2，因为在i后插入了一个. ， 多了一位。

class Solution {
public:
    vector<string> result;// 记录结果
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                //pointNum++;
                backtracking(s, i + 2, pointNum+1);   // 插入逗点之后下一个子串的起始位置为i+2
                //pointNum--;                         // 回溯
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else break; // 不合法，直接结束本层循环
        }
    }
    // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) { // 0开头的数字不合法
                return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
                return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255) { // 如果大于255了不合法
                return false;
            }
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;}
};```