菜鸟Leetcode-分治

分治

一、分治的思想

1. 分：递归地将问题分解为各个的子问题(性质相同的、相互独立的子问题)；
2. 治：将这些规模更小的子问题逐个击破；
3. 合：将已解决的子问题逐层合并，最终得出原问题的解

二、分治法适用的情况

• 原问题的计算复杂度随着问题的规模的增加而增加。
• 原问题能够被分解成更小的子问题。
• 子问题的结构和性质与原问题一样，并且相互独立，子问题之间不包含公共的子子问题。
• 原问题分解出的子问题的解可以合并为该问题的解。

三、相关练习

169. 多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:
输入: [3,2,3]
输出: 3

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/majority-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

def majorityElement(nums)->int:
    # 处理边界条件
    # 数组中没有元素
    if len(nums) == 0:
        return
    # 数组中只有一个元素
    elif len(nums) == 1:
        return nums[0]
    # 数组中有多个元素
    else:
        # 递归，分割成多个子问题求解
        # 每调用一次majorityElement函数，就进行一次二分
        left = majorityElement(nums[:len(nums)//2])
        right = majorityElement(nums[len(nums)//2:])

    # 合并子问题求解
    # 如果返回的left的众数和right的众数相等，则任意返回二者之一即为合并后的众数
    if left == right:
        return left
    # 如果left的众数和right的众数不同，则判断两个众数在整个数组中出现的次数，取出现的次数多的那个
    else:
        if nums.count(left) > nums.count(right):
            return left
        else:
            return right

a = [3,2,3]
b = majorityElement(a)
print("数组{}的众数是{}".format(a,b))

53. 最大子序和

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

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''

'''
1. 分治法：确定切分的终止条件；准备数据，将大问题切分成小问题；处理子问题，得到子结果，并合并
时间复杂度：O(nlogn)
空间复杂度：O(1)
'''
def divide_conquer_maxSubArray(nums)->int:
    #边界条件
    if not nums:
        return
    if len(nums) == 1:
        return nums[0]

    #切分子问题
    #第一种情况：左子数组的最大子序和
    left = divide_conquer_maxSubArray(nums[:len(nums)//2])
    #第二种情况：右子数组的最大子序和
    right = divide_conquer_maxSubArray(nums[len(nums)//2:])

    #第三种情况：最大子序和既包括左子数组中的元素，又包括右子数组中的元素，这种情况下，最大子数组一定包括左右分界线两边的元素
    #对于左子数组，从右往左找最大子序和
    # 设置左边最大和，初始值为左子数组中最右边的元素
    max_left = nums[len(nums)//2 - 1]
    # 记录左子数组的最大和
    tmp_left = 0
    # 从右往左找最大子序和
    for i in range(len(nums)//2 - 1, -1, -1):
        tmp_left += nums[i]
        max_left = max(max_left, tmp_left)
    #对于右子数组，从左往右找最大子序和
    # 设置右边最大和，初始值为右子数组中最左边的元素
    max_right = nums[len(nums) // 2]
    # 记录右子数组的最大和
    tmp_right = 0
    # 从左往右找最大子序和
    for i in range(len(nums)//2, len(nums)):
        tmp_right += nums[i]
        max_right = max(max_right,tmp_right)

    #合并子问题
    #返回三种情况中的最大值
    return max(left,right,max_right+max_left)

'''
2. 贪心法：如果当前指针所指元素之前的和小于0，则丢弃当前元素之前的数列
时间复杂度：O(n)
空间复杂度：O(1)
'''
def greedy_maxSubArray(nums)->int:
    #边界条件
    if not nums:
        return
    #设置max和sum初值都为数组中的第一个元素
    curr_sum = max_sum = nums[0]
    for i in range(1, len(nums)):
        curr_sum = max(nums[i], curr_sum+nums[i])
        max_sum = max(curr_sum,max_sum)
    return max_sum


'''
3. 动态规划：直接在原数组上进行运算，
如果nums[i-1]>0,则把它加到nums[i]上，如果nums[i-1]<=0,则nums[i]不变，最后返回nums[i]中最大的元素
'''
def DP_maxSubArray(nums)->int:
    # 边界条件
    if not nums:
        return
    # 如果nums[i-1]>0,则把它加到nums[i]上
    # 如果nums[i-1]<=0,则nums[i]不变
    # 最后返回nums[i]中最大的元素
    for i in range(1,len(nums)):
        if nums[i-1] > 0:
            nums[i] += nums[i-1]
    return max(nums)

a = [-2,1,-3,4,-1,2,1,-5,4]
print(divide_conquer_maxSubArray(a))
a = [-2,1,-3,4,-1,2,1,-5,4]
print(greedy_maxSubArray(a))
a = [-2,1,-3,4,-1,2,1,-5,4]
print(DP_maxSubArray(a))

50. Pow(x, n)

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

示例 1:
输入: 2.00000, 10
输出: 1024.00000

示例 2:
输入: 2.10000, 3
输出: 9.26100

示例 3:
输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

说明:
-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/powx-n
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#coding=utf-8
'''
实现 pow(x, n) ，即计算 x 的 n 次幂函数。
'''

def myPow1(x,n)->float:
    #处理n为负数的情况
    if n < 0:
        x = 1/x
        n = -n
    #确定边界条件
    if n == 0:
        return 1

    #分割子问题
    if n % 2 == 0:
        sub = myPow1(x,n/2)
        return sub*sub
    if n % 2 == 1:
        sub = myPow1(x,(n-1)/2)
        return x*sub*sub

def myPow2(x,n)->float:
    # 处理n为负数的情况
    if n < 0:
        x = 1 / x
        n = -n
    # 确定边界条件
    if n == 0:
        return 1

    # 分割子问题
    #如果n为奇数，先将原问题转化为1+偶数的情况
    if n % 2 == 1:
        p = myPow2(x,n-1)
        return x*p
    #返回偶数情况下的结果
    return myPow2(x*x, n/2)

print(myPow1(2,10))
print(myPow2(2,10))