【精选高频面试题】回溯系列：分割问题

分割问题

Leetcode.131.分割回文串

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

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

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2：

输入：s = “a”
输出：[[“a”]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

思路：分割的思想与组合的思想差不多。在循环横向遍历的时候，组合是取得a放入path,分割是截取a使其与后面ab分割开，然后判断a是否是回文，然后放入path中。组合是取得aa,放入path ,而分割是截取aa,判断aa是否是回文串，再放入到path中。再递归向下遍历的时候，组合是取得第二个a，放入path中，而分割是分割第二个a，判断这个a是否为回文串，是就放入path中。然会回溯进而截取b就截取到了ab,判断是否是回文串。

难点：

1. 如何分割：分割其实就是在于startindex这个参数，每次分割完成我们需要判断的回文串为[startindex,i]因为在一个for循环中，i不断增加。在递归循环中，字符串将会从前一个字符串之后的字符开始，一个一个的继续分割，我们就能获取所有的分割方案。

2. 什么时候递归结束，获取分割结果：当startindex的值>=s.size()时，意味着我们完成了所有的字符分割

3. 回文串判断：双指针法

   C++代码

   class Solution {
   private:
        bool isvalid(const string& s,int begin,int end){
            for(int i=begin,j=end;i<j;i++,j--){
                if(s[i]!=s[j]){
                    return false;
                }
            }
            return true;
        }
       vector<string>path;
       vector<vector<string>>res;
       void backtracking(const string&s,int startindex){
           if(startindex>=s.size()){
               res.push_back(path);
               return ;
           }
           for(int i=startindex;i<s.size();i++){
               if(isvalid(s,startindex,i)){
                   string str=s.substr(startindex,i-startindex+1);
                   path.push_back(str);
               }
               else continue;
               backtracking(s,i+1);
               path.pop_back();
           }
           return ;
       }
   public:
       vector<vector<string>> partition(string s) {
           path.clear();
           res.clear();
           if(s.size()==0)return res;
           backtracking(s,0);
           return res
       }
   };
   

Leetcode.93.复原ip地址

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效的 IP 地址。

示例 1： 输入：s = “25525511135” 输出：[“255.255.11.135”,“255.255.111.35”]

示例 2： 输入：s = “0000” 输出：[“0.0.0.0”]

示例 3： 输入：s = “1111” 输出：[“1.1.1.1”]

示例 4： 输入：s = “010010” 输出：[“0.10.0.10”,“0.100.1.0”]

示例 5： 输入：s = “101023” 输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]

提示： 0 <= s.length <= 3000 s 仅由数字组成

思路：

第一： 通过示例，我们知道这个题是分割字符串，用到回溯法。

第二：首先依据题意，我们要判断分割出来的整数是否是有效的IP，就要写一个判断函数

bool isvalid(const string&s,int start int end){
     if(start>end)return false;//确保为有效字符串
     if(s[start]=='0'&&start<end)return flase;//确保无前导0
     int num=0;
    for(int i=start;i<=end;i++){//i<=end很重要，就无法判断大于255的字符串
        if(s[i]<'0'||s[i]>'9'){//确保字符串都为有效数字
            return false
        }
        num=num*10+(s[i]-'0')；
        if(num>255)return false;
    }
    return true;
}

第三：回溯法：首先确定参数类型以及返回值。我们需要一个int值来保存分割点数量【由于这道题我们只需要在原字符串上面判断操作，我们就不需要设置path存储。只需要设置一个数组储存结果】【由于我们要修改原字符串所以参数类型为non-const】

vector<string>result;
void backtracking(string& s,int startindex,int pointnum){
    
}

第四：使用回溯法，我们首先写出终止条件：什么情况下，我们将path中的结果放入result中呢？当出现3个分割号且最后一个字符串满足有效IP的条件

if(pointnums==3){
    if(isvalid(s,startindex,s.size()-1)){
        result.push_back(path);
    }
    return ;
}

第五：单层遍历逻辑：我们需要判断每一次分割的字符串，当字符串为有效的，我们就在它的后面加分割号 ',不符合。就结束循环。同时分割号数++，之后进行回溯，分割号–。同时删除分割号

第六：由于有效IP为4个整数每个整数大小在0~255所以所给字符串的大小不大于12；

class Solution {
private:
    bool isvalid(const string&s,int start,int end){
        if(start>end)return false;
        if(s[start]=='0'&&start<end)return false;
        int num=0;
        for(int i=start;i<=end;i++){//必须取=
            if(s[i]<'0'||s[i]>'9')return false;
            num=num*10+(s[i]-'0');
            if(num>255)return false;
        }
        return true;
    }
    vector<string>result;
    void backtracking(string&s,int startindex,int pointnums){
        if(pointnums==3){
            if(isvalid(s,startindexm,s.size()-1)){
                result.push_back(s);
                return;
            }
        }
        for(int i=startindex;i<s.size();i++){
            if(isvalid(s,startindex,i)){
                s.insert(s.begin()+i+1,'.');
                pointnums++;
                backtracking(s,i+2,pointnums);
                pointnums--;
                s.erase(s.begin()+i+1);
            }
            else continue;
            
        }
    }
public:
    vector<string> restoreIpAddresses(string s) {
         result.clear();
        if(s.size()>12)return result;
        backtracking(s,0,0);
        return result;
        
    }
};