回溯算法练习——6、复原IP地址（C++和Python描述）

来源：代码随想录
本题的力扣链接：https://leetcode-cn.com/problems/palindrome-partitioning/

1、题目描述：

2、思路：

要是做过分割回文串，那么就很容易做出这道题的。是一个思路。。。

其实只要是意识到这是一个切割问题，切个问题就可以使用回溯搜索法把所有的可能性搜索出来。（感觉只要是要枚举出所有的情况，就可以使用回溯搜索法。。。）

我们抽象成树结构来分析下：

记住：横向for循环，纵向递归。

既然能抽象成一个树结构，那么我们就按照回溯搜索法的模板进行。递归三部曲：

• 1、递归参数：
  startIndex⼀定是需要的，因为不能重复分割，记录下⼀层递归分割的起始位置。

• 2、递归终止条件：
  由于要所有的字符，并且是由分割的四部分组成的，那么，终止的条件就是：分割成四段，并且四段加起来的字符长度就是源字符串的长度。

• 3、单层搜索的逻辑：
  
  
  然后就是回溯和递归的过程。。。

3、代码：

3.1 python代码：

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        res = [] # 保存结果集合
        path = [] # 收集路径上符合条件的元素

        def judge(ss: str) -> bool: # 判断是是否:每个整数位于 0 到 255 之间组成，且不能含有前导 0
            if len(ss) > 1 and ss[0] == '0':
                return False
            else:
                if int(ss) <= 255:
                    return True
                else:
                    return False

        def backtracking(startIndex):
            if startIndex == len(s) and len(path) == 4: # s中所有元素选上，并且切割成4段
                res.append('.'.join(path))
                return
            for i in range(startIndex, len(s)):
                if judge(s[startIndex:i+1]) and len(path) < 4: # # 当前节点符合条件，则加入path，len(path) < 4是剪枝
                    path.append(s[startIndex:i+1])
                else: # 这个要用break,因为在一层中，切割不合格后，后面的肯定不合格（要么有前导0，要么大于255）
                    break
                backtracking(i+1) # 递归，i+1表示当前元素不重复
                path.pop() # 回溯
        
        backtracking(0)
        return res

3.2 C++代码：

class Solution {
private:
    vector<string> res; // 记录结果集合
    
    bool judge(string s, int start, int end){ // 判断字符串s在左闭⼜闭区间[start, 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++){
            num = num * 10 + (s[i] - '0');
            if(num > 255){ // 大于255，则不合法
                return false;
            }
        }
        return true;
    }

    // startIndex:搜索的起始位置。pointNum:添加逗号的数量
    void backtracking(string& s, int startIndex, int pointNum){
        if(pointNum == 3){ // 逗点数量为3时，分割结束
            // 判断第四段⼦字符串是否合法，如果合法就放进result中
            if(judge(s, startIndex, s.size() - 1)){
                res.push_back(s);
            }
            return;
        }
        for(int i = startIndex; i < s.size(); i++){
            if(judge(s, startIndex, i)){ // 判断 [startIndex,i] 这个区间的⼦串是否合法
                s.insert(s.begin() + i + 1, '.'); // 合法，则在i的后⾯插⼊⼀个逗点
                pointNum++;
            }
            else{
                break;
            }

            backtracking(s, i+2, pointNum); // 插⼊逗点之后下⼀个⼦串的起始,因此要加2

            // 回溯，撤销操作
            pointNum--;
            s.erase(s.begin() + i + 1);
        }
    }

public:
    vector<string> restoreIpAddresses(string s) {
        if (s.size() > 12) return res; // 算是剪枝了
        backtracking(s, 0, 0);
        return res;

    }
};

4、总结：

做了这几道回溯的题之后，感觉到：
读完题后要求找出所有的可能性，那么，很大的可能就是要用回溯搜索法了。然后，
（1）在纸上抽象的画一下递归树（这个很重要，帮助理解，而且这么做，就不会乱了）；
（2）画出几个之后（记住，横向for遍历，纵向递归遍历），看题目的具体要求，确定这个树多深，也就是确定结束条件；
（3）确定递归函数的参数；
（4）还有一点就是：横向遍历时，要是想跳过某一个节点的遍历，则使用continue，要是想跳过同层之后的所有节点，则使用break。