跟随carl代码随想录刷题
语言：python

---

131. 困难分割回文串

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

题目分析

切割问题其实是一种组合问题。

关键：

• 切割问题，有不同的切割方式
  • 切割过的地方不能重复切割，所以递归函数需要传入i+1
• 判断回文
  • 可以使用双指针法，一个指针从前往后，一个指针从后往前，如果前后指针所指向的元素是相等的，就是回文字符串了。
  • python的切片yyds啊：temp == temp[::-1]

完整代码如下

切片判断回文

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        res = []
        path = []

        def backtracking(s:str, start_index:int) -> None:
            if start_index >= len(s):
                res.append(path[:])
                return

            # 单层递归逻辑
            for i in range(start_index, len(s)):
                # 判断被截取的部分是否是回文串。只有回文串才会加入结果集与进入回溯
                temp = s[start_index:i+1]  # 字符串
                if temp == temp[::-1]:
                    path.append(temp)
                    backtracking(s, i+1)
                    path.pop()
                else:
                    continue

        backtracking(s, 0)
        return res
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

双指针判断回文

class Solution:
    def __init__(self):
        self.res = []
        self.path = []

    def partition(self, s: str) -> List[List[str]]:
        
        self.backtracking(s, 0)
        return self.res

    def backtracking(self, s:str, start_index:int) -> None:
        if start_index >= len(s):
            self.res.append(self.path[:])
            return

        # 单层递归逻辑
        for i in range(start_index, len(s)):
            # 判断被截取的部分是否是回文串。只有回文串才会加入结果集与进入回溯
            if self.is_palindrom(s, start_index, i):
                self.path.append(s[start_index: i+1])
                self.backtracking(s, i+1)
                self.path.pop()
            else:
                continue
    def is_palindrom(self, s, start, end):
        i:int = start
        j:int = end
        while i<j:
            if s[i] != s[j]:
                return False
            i += 1
            j -= 1
        return True              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

93. 复原 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 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
👉示例 1：
输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]
👉示例 2：
输入：s = “0000”
输出：[“0.0.0.0”]
👉示例 3：
输入：s = “101023”
输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]

题目分析

分割问题可以使用回溯搜索法把所有可能性搜出来。

• 参数

  • 本题需要一个变量pointNum，记录添加逗点的数量。
  • startIndex：搜索的起始位置

• 终止条件：分割的段数==4，即添加的逗点数量==3。

• 单层搜索逻辑

  • 如果字符串合法，就在后面加上.
  • 回溯：下一层的startIndex要从i+2开始（因为需要在字符串中加入分隔符.），同时记录分割符的数量pointNum要+1
  • 回溯的时候，就将刚刚加入的分隔符.删掉就可以了，pointNum也要-1

判断字串是否合法

• 段位以0为开头的数字不合法
• 段位里有非正整数字符不合法
• 段位如果大于255了不合法

完整代码如下

class Solution:
    def __init__(self):
        self.result = []
    def restoreIpAddresses(self, s: str) -> List[str]:
        """
        
        """
        self.result.clear()
        if len(s) > 12: return []
        self.backtracking(s, 0, 0)
        return self.result
    
    def backtracking(self, s:str, start_Index:int, point_num:int)->None:
        if point_num == 3:
            if self.is_valid(s, start_Index, len(s)-1):
                self.result.append(s[:])
            return 
        
        for i in range(start_Index, len(s)):
            if self.is_valid(s, start_Index, i):
                s = s[:i+1] + '.' + s[i+1:]
                self.backtracking(s, i+2, point_num+1)  # 在填入`.`后，下一子串起始后移2位
                s = s[:i+1] + s[i+2:]  # 回溯
            else:
                break  # 若被截取的数字不合法，直接结束本层循环
    def is_valid(self, s:str, start:int, end:int)->bool:
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 以0开头
            return False
        if not 0 <= int(s[start:end+1]) <= 255:
            return False
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33