Python|贪心|数组|二分查找|贪心|哈希表|单选记录：买卖股票的最佳时机 II |存在重复元素 II |矩形区域不超过 K 的最大数值和

目录

1、买卖股票的最佳时机 II（贪心，数组）

选项代码：

2、存在重复元素 II（数组，哈希表）

选项代码：

3、矩形区域不超过 K 的最大数值和（数组，二分查找）

选项代码：

---

1、买卖股票的最佳时机 II（贪心，数组）

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

 

示例 1:

输入: prices = [7,1,5,3,6,4]

输出: 7

解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。

随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:

输入: prices = [1,2,3,4,5]

输出: 4

解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。

注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]

输出: 0

解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

 

提示：

• 1 <= prices.length <= 3 * 104
• 0 <= prices[i] <= 104

选项代码：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        hold = 0
        pric = []
        temp = []
        flag = 0
        msum = 0
        if len(prices) <= 2:
            if not prices:
                return 0
            if len(prices) == 1:
                return 0
            if prices[0] > prices[1]:
                return 0
            if prices[0] < prices[1]:
                return prices[1] - prices[0]
        for i in range(len(prices) - 1):
            if prices[i + 1] > prices[i] and hold != 1:
                hold = 1
                flag = i
                continue
            if prices[i + 1] < prices[i] and hold == 1:
                pric.append(prices[flag])
                pric.append(prices[i])
                hold = 0
            else:
                continue
        for i in range(0, len(pric), 2):
            temp.append(pric[i + 1] - pric[i])
            msum = sum(temp)
        if hold == 1:
            msum = msum + prices[-1] - prices[flag]
        return msum
# %%
s = Solution()
print(s.maxProfit(prices =[7,1,5,3,6,4]))

2、存在重复元素 II（数组，哈希表）

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。

 

示例 1:

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

输出: true

示例 2:

输入: nums = [1,0,1,1], k = 1

输出: true

示例 3:

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

输出: false

选项代码：

class Solution:
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        if len(list(set(nums))) == len(nums):
            return False
        left = 0
        right = left + k
        if k >= len(nums):
            return len(list(set(nums))) < len(nums)
        while right < len(nums):
            while left < right:
                if nums[left] == nums[right]:
                    return True
                else:
                    right -= 1
            left += 1
            right = left + k
        if len(list(set(nums[left:]))) < len(nums[left:]):
            return True
        return False
# %%
s = Solution()
print(s.containsNearbyDuplicate(nums = [1,2,3,1], k = 3))

3、矩形区域不超过 K 的最大数值和（数组，二分查找）

给你一个 m x n 的矩阵 matrix 和一个整数 k ，找出并返回矩阵内部矩形区域的不超过 k 的最大数值和。

题目数据保证总会存在一个数值和不超过 k 的矩形区域。

 

示例 1：

输入：matrix = [[1,0,1],[0,-2,3]], k = 2

输出：2

解释：蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2，且 2 是不超过 k 的最大数字（k = 2）。

示例 2：

输入：matrix = [[2,2,-1]], k = 3

输出：3

 

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 100
• -100 <= matrix[i][j] <= 100
• -105 <= k <= 105

 

进阶：如果行数远大于列数，该如何设计解决方案？

选项代码：

import bisect
from typing import List
class Solution:
    def maxSumSubmatrix(self, matrix: List[List[int]], k: int) -> int:
        m = len(matrix)
        Row, Col = len(matrix), len(matrix[0])
        res = float("-inf")
        for ru in range(Row):
            col_sum = [0 for _ in range(Col)]
            for rd in range(ru, Row):
                for c in range(Col):
                    if matrix[rd][c] == k:
                        return k
                    col_sum[c] += matrix[rd][c]
                presum = [0]
                cur_sum = 0
                for colsum in col_sum:
                    cur_sum += colsum
                    idx = bisect.bisect_left(presum, cur_sum - k)
                    if idx < len(presum):
                        res = max(res, cur_sum - presum[idx])
                        if res == k:
                            return k
                    bisect.insort(presum, cur_sum)
        return res
# %%

s = Solution()
print(s.maxSumSubmatrix(matrix = [[2,2,-1]], k = 3))