Leetcode-递归&分治

最新推荐文章于 2024-11-09 21:44:05 发布

albyc22660

最新推荐文章于 2024-11-09 21:44:05 发布

阅读量178

点赞数

文章标签：面试数据结构与算法

原文链接：http://www.cnblogs.com/chaojunwang-ml/p/11357165.html

版权

50. Pow(x, n) https://leetcode-cn.com/problems/powx-n/

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

说明:

-100.0 < x < 100.0

n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。

解：

直接调库函数，不过面试中肯定不可以。

暴力，写个循环直接乘，O(N)。

分治，y = x**(n/2)。 n是偶数，两部分一样只计算一边即可，res = y*y。n为奇数，res = y*x*y。一直这样算到x**1 或 x**0。时间复杂度为O(logN)。

递归实现

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if not n:
            return 1
        if n < 0:
            return 1 / self.myPow(x, -n)
        if n % 2:
            return x * self.myPow(x, n-1)   # n为奇数，通过n-1次方去做
        return self.myPow(x*x, n/2)  # n为偶数

迭代实现，分治的最小计算乘子为x。例如，x**(7) = x * x**(6) = x * (x**2)**(3) = x * (x**2) * ((x**2)**2)**1

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if not n:
            return 1
        if n < 0:     # n小于0的话就转化成n大于0的形式，把x变为1/x即可
            x = 1/x
            n = -n
            
        res = 1
        while n:   # 分治的最小单位是1次方
            if n & 1:   # n 为奇数，先乘多出来的一个x
                res *= x
            x *= x  # 基本乘子从x变为x**2
            n >>= 1  # n = floor(n/2)
        return res

169. 求众数 https://leetcode-cn.com/problems/majority-element/

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在众数。

解：

暴力，两层嵌套循环，枚举所有x，针对某一个x去数组里面计数。O(N²)

直接排序后取中间元素，肯定是众数。O(NlogN)

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        return nums[int((n-1)/2)]

遍历一次，用hashmap存元素计数，最后再去map里面看一下计数最大的元素是哪个。O(N)

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        count = dict()
        for x in nums:
            count[x] = count.get(x, 0) + 1
            
        max_count = 0
        for key, value in count.items():
            if value > max_count:
                max_count = value
                res = key
        return res   # 或者直接利用字典的get函数，一行就可以 return max(count, key=count.get)

分治递归求解，直到所有的子问题都是长度为 1 的数组。由于传输子数组需要额外的时间和空间，所以我们实际上只传输子区间的左右指针 low 和 high 表示相应区间的左右下标。

　　长度为 1 的子数组中唯一的数显然是众数，直接返回即可。

　　如果回溯后某区间的长度大于 1 ，必须将左右子区间的值合并。如果它们的众数相同，那么显然这一段区间的众数是它们相同的值。否则，需要比较两个众数在整个区间内出现的次数来决定该区间的众数。

　　原问题的答案就是下标为 0 和 n 之间的众数这一子问题。

时间复杂度为O(NlogN)

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        return self.helper(nums, 0, len(nums)-1)
    
    def helper(self, nums, low, high):
        if low == high:  # 长度为1的子数组，众数就是那唯一的元素
            return nums[low]
        
        # 子数组长度大于1，递归的去找左右数组的众数
        mid = low + (high - low) // 2
        left = self.helper(nums, low, mid)
        right = self.helper(nums, mid+1, high)
        
        if left == right:  # 判断左右两个众数的关系，如果左右众数相同，那一定是左右总体的众数
            return left  
        
        # 如果不相同，总体上count大的那个是整体的众数
        left_count, right_count = 0, 0
        for i in range(low, high+1):
            if nums[i] == left:
                left_count += 1
            elif nums[i] == right:
                right_count += 1
        
        return left if left_count > right_count else right

53. 最大子序和 https://leetcode-cn.com/problems/maximum-subarray/

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

进阶:

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

解：

动态规划，对数组进行遍历，当前最大连续子序列和为sum，结果为ans。如果sum>0，说明前面的子序列对整体有增益，保留；否则前面的子序列不要，只保留当前的遍历数。每次比较sum和ans大小，ans取最大值。O(N)

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if not nums:
            return 0
        
        res = nums[0]
        sum_ = 0
        for i in range(len(nums)):
            if sum_ > 0:
                sum_ += nums[i]
            else:
                sum_ = nums[i]
            if sum_ > res:
                res = sum_
        return res

分治，和最大的子序列要么在左半边，要么在右半边，要么跨过左右。在左右两边的情况直接递归求解，在中间的情况，子序列连续且跨越mid点，说明在左右两边都是连续的，分别自右向左、自右向左找最大连续子序列。O(N*logN)

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return nums[0]
        
        n = len(nums)
        
        # 分别计算左右两边的最大子序列和
        mid = (n-1) // 2
        left = self.maxSubArray(nums[: mid+1])
        right = self.maxSubArray(nums[mid+1:])
        
        # 计算跨越左右两边的情况，即从右向左计算左边的最大子序列和，再从左向右计算右边的最大子序列和，相加即可
        medium_l = nums[mid]
        tmp = 0
        for i in range(mid, -1, -1):
            tmp += nums[i]
            medium_l = max(medium_l, tmp)
        
        medium_r = nums[mid+1]
        tmp = 0
        for i in range(mid+1, n):
            tmp += nums[i]
            medium_r = max(medium_r, tmp)
            
        medium = medium_l + medium_r
        
        return max(left, right, medium)  # 返回三种情况中的最大值，就是当前数组中的最大子序列和

438. 找到字符串中所有字母的异位词 https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。

解：

暴力，枚举每个可能的子串起始索引，再直接判断是否为异位词，O(N*K)

滑动窗口+哈希表，还是哈希表来存p的字符，枚举每个可能的子串起始索引，用哈希表判断，O(N)

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        if not s:
            return []
        
        def build_map(p):
            aph_map = dict()
            for c in p:
                aph_map[c] = aph_map.get(c, 0) + 1
            return aph_map
        
        p_map = build_map(p)
        
        s = list(s)
        n, k = len(s), len(p)
        
        base_map = build_map(s[:k])  # 遍历的过程中每次走一个元素又来一个元素，始终维护这个hashmap
        res = []
        
        for i in range(n-k+1):
            if base_map == p_map:
                res.append(i)
            if i != n-k: 
                # s[i] 退出去
                tmp = base_map.get(s[i])-1
                if tmp:
                    base_map[s[i]] = tmp
                else:
                    base_map.pop(s[i])
                base_map[s[i+k]] = base_map.get(s[i+k], 0) + 1  # s[i+k] 进来
       
        return res

437. 路径总和iii https://leetcode-cn.com/problems/path-sum-iii/

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

解：

注意这道题路径的起点和终点都可以是任意的，所以在dfs的时候不好直接计数，还是要在遍历到某个节点node的时候把之前所有可能的路径和作为一个list传进来，新的路径和就包括原先的路径和加上node.val，以及从node开始的新路径、和为node.val。然后左右节点dfs即可。

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        if root is None:
            return 0
        
        # sums为node的父节点已能构成的和，返回最长可延伸到node结束的所有路径所能构成的和列表
        def dfs(node, sums):
            left = right = 0  # 左右的值默认为0
            
            # 算上node以后，可能的路径和包括，之前的和加当前结点值能构成的新和，以及从当前结点开始算的新和
            tmp = [num + node.val for num in sums] + [node.val]
            
            if node.left:
                left = dfs(node.left, tmp)  # 左右子树dfs搜索
                
            if node.right:
                right = dfs(node.right, tmp) 
                
            return tmp.count(sum) + left + right  

        return dfs(root, [])

设计一个比较好的递归函数。双递归。

pathSum函数，给定一个节点和目标值，返回以这个节点为根的树中，和为目标值的路径总数。

count函数，给定一个节点和目标值，返回这个节点为根的树中，以这个节点为路径开头，和为目标值的路径总数。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        if root is None:
            return 0
        return self.count(root, sum) + self.pathSum(root.left, sum) + self.pathSum(root.right, sum)  # root中路径数=以root开头的路径数+不以root开头的路径数
    
    def count(self, node, sum):
        if node is None:
            return 0
        tmp = 0
        if node.val == sum:
            tmp += 1
        tmp += self.count(node.left, sum - node.val) + self.count(node.right, sum - node.val) 
        return tmp

4. 寻找两个有序数组的中位数 https://leetcode-cn.com/problems/median-of-two-sorted-arrays/

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

解：

先不考虑时间复杂度要求，双指针遍历的做法。维护一个数组res存放到中位数mid和后一个数mid+1，如果中位数是一个数，返回res[-2]；如果需要除以2，返回(res[-1]+res[-2])/2。比较烦人的是要注意一个nums为空的情况，以及判断好是否需要向res中添加元素的条件。

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        if not nums1 and not nums2:
            return 0.
        elif not nums1:
            n = len(nums2)
            return float(nums2[n//2]) if n%2 != 0 else (nums2[(n//2)-1]+nums2[(n//2)])/2
        elif not nums2:
            n = len(nums1)
            return float(nums1[n//2]) if n%2 != 0 else (nums1[(n//2)-1]+nums1[(n//2)])/2
        
        
        m, n = len(nums1), len(nums2)
        target_len = (m+n)//2 + 1 if (m+n) % 2 == 0 else (m+n)//2 + 2
        i, j = 0, 0 
        res = []
        while i < m and j < n:
            if nums1[i] < nums2[j]:
                res.append(nums1[i])
                i += 1
            else:
                res.append(nums2[j])
                j += 1
            if len(res) == target_len:
                break
    
        if i < m:
            while i < m:
                if len(res) == target_len:
                    break
                res.append(nums1[i])
                i += 1
          
        if j < n:
            while j < n:
                if len(res) == target_len:
                    break
                res.append(nums2[j])
                j += 1
                
        if (m+n) % 2 == 0:
            return (res[-1]+res[-2])/2
        return float(res[-2])

要找到中位数的话就是要把A和B在某个位置i和j切分成两部分，left_A和left_B共同构成left，right_A和right_B共同构成right，只要left和right长度相等且max(left) <= min(right)，那么中位数就等于( max(left) + min(right) )/2。如何找边界值，可以用二分法，先确定 num1 取 m1 个数的左半边，那么 num2 取 m2 = (m+n+1)/2 - m1 的左半边，找到合适的 m1，就用二分法找。

当 [ [a1],[b1,b2,b3] | [a2,..an],[b4,...bn] ]

只需要比较 b3 和 a2 的关系的大小，就可以知道这种分法是不是准确的

例如：nums1 = [-1,1,3,5,7,9]，nums2 =[2,4,6,8,10,12,14,16]

当 m1 = 4, m2 = 3，它的中位数就是median = (num1[m1] + num2[m2])/2

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        n1, n2 = len(nums1), len(nums2)
        if n1 > n2:
            nums1, nums2, n1, n2 = nums2, nums1, n2, n1   # 保证 n2 >= n1，便于判断边界
            
        k = (n1 + n2 + 1) // 2  # 令left和right两部分长度相同的全局切分位置
        left = 0
        right = n1-1
        while left <= right:  # 二分的在nums1中找到一个位置m1，使得 nums1[m1] == nums2[k-m1-1]
            m1 = left + (right - left) // 2  
            m2 = k - m1
            if nums1[m1] < nums2[m2-1]:
                left = m1 + 1
            else:
                right = m1 - 1 
                
        m1 = left   # 如果不存在相等的数，nums1[left]也是第一个大于nums[k-left]的数或者left=n1
        m2 = k - m1 
        
        c1 = max(nums1[m1-1] if m1 > 0 else float("-inf"), nums2[m2-1] if m2 > 0 else float("-inf") )
        
        if (n1 + n2) % 2 == 1:
            return c1
        
        c2 = min(nums1[m1] if m1 < n1 else float("inf"), nums2[m2] if m2 <n2 else float("inf"))
        return (c1 + c2) / 2

转载于:https://www.cnblogs.com/chaojunwang-ml/p/11357165.html