回溯问题（三）：切割问题

131. 分割回文串
 给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。

1、切割问题抽象化

因此，切割问题中需要递归传递的也只有一个参数：当前应该从哪里继续切割

2、代码实现

class Solution {
    vector<vector<string>> res;
    vector<string> path;

	/-----递归函数-----/
    void backTracking(string& s, int startIndex){
    	/----递归终止条件：如果当前开始是从尾后开始的，说明已经找到了一组可行解-----/
        if(startIndex == s.size()){
            res.push_back(path);
            return;
        }

		/----递归处理当前节点----/
        for(int i = startIndex; i < s.size(); i++){
        	//只有找到了从当前节点开始的一个回文串，才有递归继续寻找的必要
            if(isPalind(s, startIndex, i)){
                string pathNow = s.substr(startIndex, i - startIndex + 1);  //获取该回文串

				/---回溯部分---/
                path.push_back(pathNow); 
                backTracking(s, i + 1);
                path.pop_back();
                
            }
        }
    }

	/-----回文串判定---/
    bool isPalind(string& s, int beg, int end){
        while(beg < end){
            if(s[beg] != s[end]) return false;
            beg++;
            end--;
        }
        return true;
    }
public:
	/---调用回溯解决问题----/
    vector<vector<string>> partition(string s) {
        res.clear();
        path.clear();
        backTracking(s, 0);
        return res;
    }
};

98、复原 IP 地址
给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 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、问题抽象

2、代码实现

class Solution {
private:
    vector<string> res;
    vector<int> path;
    /-----递归参数，当前开始寻找分割位置的坐标-----/
    void backTracking(string& s, int startIndex){
    	/---递归终止条件1：如果已经分割了四节以上，没找到可行解---/
        if(path.size() > 4) return;
        /---递归终止条件2：如果已经分割了四节但数组还有数字，没找到可行解---/
        if(path.size() == 4 && startIndex != s.size()) return;
        /---递归终止条件3：数组正好分割成了四节，找到了可行解，将答案存储---/
        if(path.size() == 4 && startIndex == s.size()){
            string pathNow = "";
            for(int i = 0; i < 3; i++){
                pathNow += to_string(path[i]) + ".";
            }
            pathNow += to_string(path[3]);
            res.push_back(pathNow);
            return;
        }

		/---以当前开始节点，分别截取1-3长度的字符串---/
        for(int i = 1; i < 4 && startIndex + i - 1< s.size(); i++){
        	/---如果首字符为0，则只能截取长度为1的字符串---/
            if(s[startIndex] == '0'){
                path.push_back(stoi(s.substr(startIndex, i)));
                backTracking(s, startIndex + 1);
                path.pop_back();
                break;
            }
			
			/---如果首字符不是0，则可以截取长度为1,2，3三种字符串---/
            if(stoi(s.substr(startIndex, i)) <= 255){
                path.push_back(stoi(s.substr(startIndex, i)));
                backTracking(s, startIndex + i);
                path.pop_back();
            }
        }
    }

/-----调用递归解决问题-----/
public:
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        path.clear();
        backTracking(s, 0);
        return res;
    }
};