代码随想录day24|复原IP地址,子集,子集II

文章: 代码随想录

子集:

思路：

其实也是经典的模板问题，要注意的是：

因为是子集问题,所以[2,1],[1,2]是重复的,所以i要等于starIndex（排列问题才会从0开始选取startIndex之前的元素）往后选取不能选取之前的元素. 这题有点不一样,是要把遍历过程所有结果添加入子集,所以path.add的位置会发生变化。

代码:

   List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> subsets(int[] nums) {
        if (nums == null) return result;
        backTracking(nums, 0);
        return result;
    }

    private void backTracking(int[] nums, int startIndex) {
        //这个要在遍历过程中把所有遍历过的结果都保存下来,所以每次递归遍历都要添加
        result.add(new ArrayList<>(path));
        if (startIndex >= nums.length) {
            return;
        }
        for (int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);
            backTracking(nums,i+1);
            path.remove(path.size()-1);
        }
    }

子集II

思路：

要用到树层去重,就是单个结果集内的重复元素可以被接受，但是不允许重复的结果集出现.

和之前的组合II题目一样,要取重复元素的最大集合,所以得从第一个重复元素开始从前往后递归搜集结果集,后面相同的元素就都跳过。

代码：

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums == null) return result;
        Arrays.sort(nums);
        backTracking(nums, 0);
        return result;
    }

    private void backTracking(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));

        if(startIndex >= nums.length) return;
        for (int i= startIndex; i<nums.length; i++){
            //树层去重
            //这里i>startIndex而不是0是因为如果是0的话,就变成树层和树枝一起去重了
            //当前同树枝下是允许相同重复值的,如果判断条件是0,那么当前层下的重复元素也会被去重,树枝也去重了,结果集就会少很多.
            if( i>startIndex && nums[i] == nums[i-1]) continue;
            path.add(nums[i]);
            backTracking(nums, i+1);
            path.remove(path.size()-1);
        }



    }

实现IP地址：

这里其实和分割回文串的思路是一样的,也是找不同的切割方式.不一样的地方就在于这里是判断是否是有效的IP地址并且有切割次数的限制。

//因为IP地址由4位数组成,最多只能切三次,(逗号)。

//题目给出了有效IP的界定:每个整数位于 0 到 255 之间组成，且不能含有前导 0

//同集合遍历,startIndex代表开始,i代表结尾.

这里如果直接用stringBuilder记录一个新字符串来插入结果集的话不好处理,没办法判断插入移出的字符串长度为多少.除非用list记录最后再用stringBuilder拼接,那这样时间和空间复杂度就比较高.

那么我们可以换个思路直接改变字符串本身,控制插入的点,因为点的长度是恒定的。  那么我们需要用参数s构建一个stringBuilder以此方便字符串的操作.

代码:

 static  List<String> result = new ArrayList<>();



    public static List<String> restoreIpAddresses(String s) {
        if (s == null) return result;
        StringBuilder sb = new StringBuilder(s);
        backTracking(sb, 0, 0);
        return result;
        }

    private static void backTracking(StringBuilder s, int startIndex, int pointNumber) {
        if (pointNumber == 3) {
            //判断最后一个
            if (isValidIP(s, startIndex, s.length() - 1)) {
                result.add(s.toString());
                //用集合的话需要把最后加入的这个元素再移除出去,
                //不然往上回弹的时候就会弹出这个最后加入的第四个元素,但是按照逻辑上一层应该弹出第三个元素,因为第四个元素是在这一层才加入的.
                //所以最后还得弹出这个元素.

            }
            return;
        }
        for (int i = startIndex; i < s.length(); i++) {
            //因为如果当前切割点不合格的话,后续的切割就更不可能合格,这点和回文子串不一样,回文子串"ab"不合格但是"aba"合格
            //IP地址的话,如果当前被判断不合格,往后找也找不到合格的切割方式,并且后面的组合也不需要看.
            if (!isValidIP(s, startIndex, i) ) break;
            //合格情况,那就找下一个区间的合格地址组合.
            s.insert(i + 1, '.');
            backTracking(s, i + 2, pointNumber + 1);
            s.deleteCharAt(i + 1);
        }
    }

    private static boolean isValidIP(StringBuilder s, int startIndex, int end) {
        if (startIndex > end) return false;
        //以0开头
        if (s.charAt(startIndex) == '0' && startIndex != end) return false;
        //测试用例的string可能会超过int的最大值,会溢出,所以不能用parseInt
//        int num=Integer.parseInt(s.substring(startIndex,end+1));

        int num=0;
        for(int i = startIndex; i <= end; i++){
            int digit = s.charAt(i) - '0';
            num = num * 10 + digit;
            if(num > 255)
                return false;
        }
        return true;
    }