算法训练第22天|491.递增子序列|46.全排列|47.全排列 II

LeetCode 491.递增子序列

题目链接：491.递增子序列

题目讲解：代码随想录

题目描述：给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

本题目需要考虑去重，但是不能像以往那样处理，因为该数组不能排序，所以不能使用used数组标记是否使用过，所以使用map来处理。

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

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

        used := make(map[int]bool, len(nums)) // 主要是对 同层 元素去重

        for i := start; i < len(nums); i++{
            if used[nums[i]]{ // 去重
                continue
            }

            if len(path) == 0 || nums[i] >= path[len(path)-1]{
                path = append(path, nums[i])
                used[nums[i]] = true
                backtracking(nums, i+1)
                path = path[:len(path)-1]
            }
        }
    }

    backtracking(nums, 0)
    return res
}

LeetCode 46.全排列

题目链接：46.全排列

题目讲解：代码随想录

题目描述：给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

func permute(nums []int) [][]int {
    path := []int{}
    res := [][]int{}
    used := make([]bool, len(nums))

    var backtracking func(nums []int)

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

        for i := 0; i < len(nums); i++{
            if used[i] != true{
                path = append(path, nums[i])
                used[i] = true
                backtracking(nums)
                used[i] = false
                path = path[:len(path)-1]
            }
        }
    }

    backtracking(nums)
    return res
}

LeetCode 47.全排列 II

题目链接：47.全排列 II

题目讲解：代码随想录

题目描述：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

本题相对于上一题，需要考虑去重。

func permuteUnique(nums []int) [][]int {
    path := []int{}
    res := [][]int{}
    used := make([]bool, len(nums))

    sort.Ints(nums)

    var backtracking func(nums []int)

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

        for i := 0; i < len(nums); i++{
            if i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false{ // 对同层元素去重
                continue
            }

            if used[i] == false{
                path = append(path, nums[i])
                used[i] = true
                backtracking(nums)
                used[i] = false
                path = path[:len(path)-1]
            }
        }
    }

    backtracking(nums)
    return res
}