【回溯算法part04】复原IP地址，子集

最新推荐文章于 2024-10-08 20:32:22 发布

前端Kesar

最新推荐文章于 2024-10-08 20:32:22 发布

阅读量51

点赞数

文章标签：算法 javascript

本文链接：https://blog.csdn.net/xiao_hkq/article/details/131677678

版权

文章介绍了如何使用回溯算法解决两个问题：一是从给定的数字字符串中恢复所有可能的有效IP地址；二是生成整数数组的所有子集，包括幂集。在IP地址问题中，重点在于验证每段数字的合法性，而在子集问题中，处理了有无重复元素的情况，并通过递归实现子集的遍历。

摘要由CSDN通过智能技术生成

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

输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]

递归终止条件：已有三段子串的条件下，判断剩余的第四段是否合法，如果合法就加入到结果集中


/**
 * @param {string} s
 * @return {string[]}
 */
var restoreIpAddresses = function(s) {
    let result = [];
    let path = [];
    let startIndex = 0;
    var backTracking = function (startIndex) {
        
        // if (startIndex >= s.length) {
            if (path.length == 3) {
                let str2 = s.slice(startIndex,s.length)
                if (isIpAddress(str2)) {
                    path.push(str2);
                    result.push([...path].join("."));
                    path.pop();
                }
                return;
            }
        // }
        for (let i = startIndex; i < s.length; i++) {
            let str = s.slice(startIndex,i+1);
            if (isIpAddress(str)) {
                path.push(str);
                backTracking(i+1);
                path.pop();
            }else{
                continue;
            }
            
        }
    }

    backTracking(startIndex);
    return result;
};
//判断是否合法
var isIpAddress = function (s) {
    if (s.length == 1) {
        return true;
    }
    if(s.length > 1){
       if (s[0] == "0") {
            return false
       } else if(parseInt(s) > 255 || parseInt(s) < 0){
            return false;
       }
       return true
    }
    return false;
}
restoreIpAddresses("0000")


链接：https://leetcode.cn/problems/restore-ip-addresses/solutions/2340742/hui-su-fen-ge-fu-yuan-ipdi-zhi-by-xiao-x-s49x/

2.子集1

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

把求子集抽象为树型结构，如下：
请添加图片描述
从图中红线部分，遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合。

var subsets = function(nums) {
    let result = [];
    let path = [];
    let startIndex = 0;
    var sub = function (nums,startIndex) {
        result.push(Array.from(path));
        for(let i = startIndex;i<nums.length;i++){
            path.push(nums[i]);
            sub(nums,i+1);
            path.pop();
        }
    }
    sub(nums,startIndex);
    return result;
};
subsets([1,2,3])

3.子集2

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

输入: [1,2,2] 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

同一树枝上可以重复选取重复元素，同一树层上不可以重复选取；
去重需要先对集合排序
请添加图片描述

var subsetsWithDup = function(nums) {
    let result = [];
    let path = [];
    let startIndex = 0;
    // let used = [];
    let arr = nums.sort((a,b)=>{return a-b;})
    var subsets = function (arr,startIndex) {
        result.push([...path]);
        for(let i = startIndex;i < arr.length;i++){
            if(i > startIndex && arr[i] == arr[i-1]){
            	// 同一树层去重
                continue;  
            }
            // used[i] = true;
            path.push(arr[i]);
            subsets(arr,i+1);
            path.pop();
            // used[i] = false;
        }
    }
    subsets(arr,startIndex);
    return result;
};
subsetsWithDup([1,2,2])