算法训练第21天|93.复原IP地址|78.子集|90.子集II

LeetCode 93.复原IP地址

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

func restoreIpAddresses(s string) []string {
    path := []string{}
    res := []string{}

    var backtracking func(s string, start int)
    backtracking = func(s string, start int){
        if len(path) == 4{ // 够4段后就不再继续往下递归
            if start == len(s){
                str := strings.Join(path, ".")
                res = append(res, str)
            }
            return
        }

        for i := start; i < len(s); i++{
            if i != start && s[start] == '0'{ // 去除0开头的组合，例如：012这种，但是单独为0是可以的
                break
            }
            str := s[start : i + 1]
            num, _ := strconv.Atoi(str)
            if num >= 0 && num <= 255{
                path = append(path, str)
                backtracking(s, i+1)
                path = path[:len(path)-1]
            }else{
                break
            }
        }
    }

    backtracking(s, 0)
    return res
}

LeetCode 78.子集

题目链接：78.子集

题目讲解：代码随想录

题目描述：给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的

子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集

func subsets(nums []int) [][]int {
    path := []int{}
    res := [][]int{}

    var backtracking func(nums []int, start int)

    backtracking = func(nums []int, start int){
        tmp := make([]int, len(path))
        copy(tmp, path)
        res = append(res, tmp)

        for i := start; i < len(nums); i++{
            path = append(path, nums[i])
            backtracking(nums, i+1)
            path = path[:len(path)-1]
        }
    }

    backtracking(nums, 0)
    return res
}

LeetCode 90.子集II 

题目链接：90.子集II 

题目讲解：代码随想录

题目描述：

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 

子集（幂集）。解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列

func subsetsWithDup(nums []int) [][]int {
    path := []int{}
    res := [][]int{}

    flag := make([]bool, len(nums))

    sort.Ints(nums)

    var backtracking func(nums []int, start int)

    backtracking = func(nums []int, start int){
        tmp := make([]int, len(path))
        copy(tmp, path)
        res = append(res, tmp)

        for i := start; i < len(nums); i++{
            if i > 0 && nums[i] == nums[i-1] && flag[i-1] == false{
                continue
            }

            path = append(path, nums[i])
            flag[i] = true
            backtracking(nums, i+1)
            flag[i] = false
            path = path[:len(path)-1]
        }
    }

    backtracking(nums, 0)
    return res
}