【Leetcode】回溯 | 分割问题 / 分隔回文串 / 复原IP地址

131 分割回文串

工具函数，判断回文串：

	public boolean isPalindrome(char[] words, int l, int r) {
        int j = r;
        for (int i = l; i <= j; i++) {
            if (words[i] != words[j]) {
                return false;
            }
            j--;
        }
        return true;
    }

递归的情况划分：判断第一刀割在什么位置，第一刀之前的串不再切割，判断是否回文，如果回文可以继续进行递归。

保存递归路径：DFS中使用StringBuilder记录当前切割第一刀的字符串。全局变量stack记录切割情况。

class Solution {
    Stack<String> stack = new Stack<>();
    List<List<String>> res = new ArrayList<>();
    
	public boolean isPalindrome(char[] words, int l, int r) {...}

    public List<List<String>> partition(String s) {
        DFS(s.toCharArray(), 0);
        return res;
    }

    public void DFS(char[] str, int l) {
        if (l >= str.length) {
            res.add(new ArrayList<>(stack));
        }
        StringBuilder sBuilder = new StringBuilder();
        // 从str[l:]进行分割
        // str[l:i] + str[i+1:]
        for (int i = l; i < str.length; i++) {
            sBuilder.append(str[i]);
            // 如果切割的位置是回文的，才有必要继续向下遍历
            if (isPalindrome(str, l, i)) {
                stack.push(sBuilder.toString());
                DFS(str, i + 1);
                stack.pop();
            }
        }
    }
}

93 复原IP地址

还是分割，但是细节比较多的分割。

辅助函数，从stack得到Ip地址：

    public String getIp(LinkedList<String> segments) {
        StringBuilder ip = new StringBuilder();
        for (int i = 0; i < segments.size() - 1; i++) {
            ip.append(segments.get(i)).append('.');
        }
        ip.append(segments.get(segments.size() - 1));
        return ip.toString();
    }

分割的终止条件：

• 分割了4次
• 如果到了尽头，就把stack加入res，否则直接return

从一个位置向后找3个数字，如果有前导0或者大于255可直接break。

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

class Solution {
    LinkedList<String> stack = new LinkedList<String>();
    List<String> res = new ArrayList<>();

    public String getIp(LinkedList<String> segments) { }

    public List<String> restoreIpAddresses(String s) {
        DFS(s.toCharArray(), 0);
        return res;
    }

    public void DFS(char[] ip, int l) {
        if (stack.size() >= 4) {
            if (l == ip.length) {
                res.add(getIp(stack));
            }
            return;
        }

        // 切割nums[l:i]
        int value = 0;
        for (int i = l; i < l + 3 && i < ip.length; i++) {
            int num = ip[i] - '0';
            value = value * 10 + num;
            // 不接受以0开头的数字(除了0
            if (i == l + 1 && value < 10) {
                break;
            }
            // 大于255，不必继续
            if (value > 255) {
                break;
            }
            stack.addLast(Integer.toString(value));
            DFS(ip, i + 1);
            stack.removeLast();
        }
    }
}