[leetcode] Python(34)--买卖股票的最佳时机(121)、最大子序和(53)、打家劫舍(198)、打乱数组(384)

从零开始的力扣（第三十四天）~

1.买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
—————————————————————————————————————————

只能使用动态规划才能满足情况，使用普通的算法会超时，思路就是第i次的最大值=max(前i-1次的最大值，第i次价格-前i-1的价格中最小的)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_price, min_price = 0, 999999
        for i in range(len(prices)):
            min_price = min(min_price, prices[i])
            max_price = max(max_price, prices[i] - min_price)
        return max_price

2.最大子序和

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

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

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

继续动态规划，判断之前所得序列的正负性，若为负，则不要，并且每次保存所得数字大小，求得最长子数组

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        ans = 0
        max = nums[0]
        for i in range(len(nums)):
            ans += nums[i]
            if ans > max:
                max = ans            
            if ans < 0:
                ans = 0
        return max

3.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:
输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 2:
输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
—————————————————————————————————————————

先考虑的是递归方法，找到以第一个数与第二个数开头的余下数列中最大的组合方式，不过会超时，这里放一下

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]
        if len(nums) == 2:
            return max(nums)
        ans1 = nums[0] + self.rob(nums[2:])
        ans2 = nums[1] + self.rob(nums[3:])
        return max(ans1, ans2)

还是使用动态规划方法，动态方程dp[i] = max(dp[i-2]+nums[i], dp[i-1])

class Solution:
    def rob(self, nums: List[int]) -> int:
        last = 0 
        now = 0
        for i in nums: 
            last, now = now, max(last + i, now)
        return now

4.打乱数组

打乱一个没有重复元素的数组。

示例:

// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);

// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();

// 重设数组到它的初始状态[1,2,3]。
solution.reset();

// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();
—————————————————————————————————————————

这里不考虑使用random模块自带的shuffle函数，可以使用randint函数随机取列表内的每一位

class Solution:

    def __init__(self, nums: List[int]):
        self.nums = nums

    def reset(self) -> List[int]:
        """
        Resets the array to its original configuration and return it.
        """
        return self.nums

    def shuffle(self) -> List[int]:
        """
        Returns a random shuffling of the array.
        """
        import random
        num = self.nums[:]
        ans = []
        while len(num) > 1: 
            a = random.randint(0, len(num) - 1)
            ans.append(num[a])
            num.pop(a)
        ans += num
        return ans
        


# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()

以上就是今日经验！