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 中的任何数字。你可以按 任何 顺序返回答案。

链接

93. 复原 IP 地址 - 力扣（LeetCode） (leetcode-cn.com)

 

解法一：

class Solution {
    List<String> res = new ArrayList<>();
    // Deque<Integer> path = new LinkedList<>();

    public List<String> restoreIpAddresses(String s) {
        if (s.length()<4 || s.length() >12) return res;
        BackTracking(s, 0, 0);
        return res;
    }

    public void BackTracking(String s, int index, int pointNums) {
        // 此时，判断最后一段
        if(pointNums == 3) {
            if (isValid(s, index, s.length() - 1)) {
                res.add(s);
            }
            return;
        }
        for (int i = index; i < s.length(); i++) {
            if (isValid(s, index, i)) {
                s = s.substring(0, i + 1) + '.' + s.substring(i + 1);
                pointNums++;
                BackTracking(s, i + 2, pointNums);
                pointNums--; // 回溯
                s = s.substring(0, i + 1) + s.substring(i + 2); // 回溯删掉逗点
            }else {
                break; // 用else后break，相当于剪枝
            }
        }
    }

    public boolean isValid(String s, int start, int end) { // 双指针判断
        if (start > end) return false;
        int len = end - start + 1;
        //当前为0开头的且长度大于1的数字需要剪枝
        if (len > 1 && s.charAt(start) == '0') {
            return false;
        }
        //将当前截取的字符串转化成数字
        int JudgeNum = len <= 0? 0 : Integer.parseInt(s.substring(start,end + 1));
        //判断截取到的数字是否符合
        return JudgeNum >= 0 && JudgeNum <= 255;
    }
}

 

解法二：

class Solution {

    List<String> res = new ArrayList<>();
    Deque<String> path = new ArrayDeque<>(4);
    String s;
    public List<String> restoreIpAddresses(String s) {
        this.s = s;
        dfs(0, 4);
        return res;
    }
    //剔除一些不变量，最后只保留当前索引和剩余段数
    public void dfs(int begin, int reside){
        if(begin == s.length()){
            //当遍历到最后一个字符且剩余段数为0时，将此时的path添加到结果中
            if(reside==0){
                res.add(String.join(".", path));
            }
            return;
        }
        //每段最多只截取3个数
        for(int i=begin; i<begin+3; i++){
            if(i >= s.length())
                break;
            //字符串剩余长度和分段所需长度
            if(s.length()-i > reside*3)
                continue;
            //当截取的字符串满足条件
            if(judgeNumber(s, begin, i)){
                String curS = s.substring(begin, i+1);
                path.addLast(curS);
                dfs(i+1, reside-1);
                path.removeLast();
            }
        }
    }

    public boolean judgeNumber(String s, int left, int right){
        int len = right - left + 1; 
        //当前为0开头的且长度大于1的数字需要剪枝
        if(len>1 && s.charAt(left)=='0')
            return false;
        //将当前截取的字符串转化成数字
        int res = len<=0 ? 0 : Integer.parseInt(s.substring(left, right+1));
        //判断截取到的数字是否符合
        return res>=0 && res<=255;
    }
}

 

参考

carl