刷题 9/20

子集

链接：题目链接

题目描述

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

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

示例:

输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

解题思路—回溯递归

这种列举可能情况的，大多都可以往回溯递归上面靠一靠
回溯递归，我们主要看它的调用栈，回溯就是出栈

代码实现

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        n = len(nums)
        
        def helper(i, tmp):
            res.append(tmp)
            for j in range(i, n):
                helper(j + 1,tmp + [nums[j]] )
        helper(0, [])
        return res  
# result: [], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]
# 回溯递归

搜索旋转排序数组

链接：题目链接

题目描述

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

解题思路—二分搜索

因为排序，加上logn的算法复杂度，首先想到的就是二分搜索了
可以发现，这个数组是局部有序的，我们如果将数组分成两半，那么一定有一半是有序的，甚至两个都是有序的
那么我们在有序的那一半进行判断，如果target在有序的那一半，那么就将搜索范围缩小到有序的那一半去
否则呢，我们去另一个非全部有序的那一半数组去继续对半分，再去找

代码实现

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = (l + r) // 2
            if nums[mid] == target:
                return mid
            if nums[0] <= nums[mid]:
                if nums[0] <= target < nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            else:
                if nums[mid] < target <= nums[len(nums) - 1]:
                    l = mid + 1
                else:
                    r = mid - 1
        return -1

## 二分搜索