93. 复原 IP 地址 -dfs

最新推荐文章于 2023-06-07 22:30:45 发布

junewgl

最新推荐文章于 2023-06-07 22:30:45 发布

阅读量359

点赞数

分类专栏： LeetCode 文章标签：深度优先算法 leetcode

本文链接：https://blog.csdn.net/qq_40755094/article/details/123543678

版权

LeetCode 专栏收录该内容

58 篇文章 0 订阅

订阅专栏

1.题目

2.思路

一看见这个就是dfs的写法，或者叫做回溯的思想。

dfs(int index, int cnt, String temp, String s);

index : 遍历字符串的索引，最大为s.length()

cnt:记录当前已经拥有切分整数个数，最大为4

temp:记录当前已经形成的字符串，记得加点.

s:代表原来的字符串


// 时间复杂度：3^4 * 20
// 对于第一个节点来说，构造一棵树，有三个节点，树的深度最大为4，所以此时时间复杂度为3^4
// 总共有字符串大小的长度的节点，也就是20个。
// 所以最终时间为 3^4 * 20
class Solution {
    List<String>ans = new ArrayList();
    int n ;
    public List<String> restoreIpAddresses(String s) {
        n = s.length();
        if(n <= 3)return ans;
        dfs(0, 0, "", s);
        return ans;
    }

// cnt -记录切分的整数个数
// indeex -记录遍历的索引的位置
    public void dfs(int index, int cnt, String temp, String s){
        if(index == n){
            if(cnt == 4){
                ans.add(temp);
            }
            return ;
        }
        if(cnt == 4) return ; //代表后面还有数字
        int preFlag = 1; //代表前面是否加.
        if(index == 0) preFlag = 0;
        // 可以选1，2，3位数字
        for(int i = 1; i <= 3; i++){
            String res = temp;
            if(preFlag == 1)res = res + "." ;
            if(index + i <= n){
                String s2 = s.substring(index, index + i);
                if(Double.parseDouble(s2) >=0 && Double.parseDouble(s2) <= 255 ){
                    if(i != 1 && s2.charAt(0) == '0'){
                        continue;
                    }
                    res += s2;
                    dfs(index + i, cnt + 1, res, s);
                       
                }
               
            }
           
        }
        return ;
    }
}

时间复杂度如何分析？ --3^4 * s.length()

dfs的时间复杂度分析基本一样的。--找树的子节点个数和树的深度，以及有多少颗这样的树！！

首先以第一个节点为例，可以产生3个子节点（也就是三个dfs(),对于当前元素，可以有三个不同的操作，选择1位，选择2位，选择3位，因为数字范围是0-255，所以最大是3位，最小是1位。）对于第一个节点形成的树，深度大小为4，因为最多只能有四次这样的操作，因为IP地址整数个数为4，所以这个节点的时间复杂度为 3^4.

当第一个节点的树都遍历完后，那么下一个节点可能就是选择前2个数作为起点，再下一个起点就是选择前3个节点作为起点，按照答案的意思，可以选择前20个数作为起点，所以是有20颗这样的树。所以最终为3^4 * s.length()。实际过程中会比这个少很多，因为会有结束条件提前结束。