add new script

Author: DSXiangLi

script/[215]数组中的第K个最大元素.py

@@ -0,0 +1,61 @@
+# 给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。 
+# 
+#  请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。 
+# 
+#  
+# 
+#  示例 1: 
+# 
+#  
+# 输入: [3,2,1,5,6,4], k = 2
+# 输出: 5
+#  
+# 
+#  示例 2: 
+# 
+#  
+# 输入: [3,2,3,1,2,4,5,5,6], k = 4
+# 输出: 4 
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= k <= nums.length <= 105 
+#  -104 <= nums[i] <= 104 
+#  
+#  Related Topics 数组 分治 快速选择 排序 堆（优先队列） 
+#  👍 1787 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def findKthLargest(self, nums: List[int], k: int) -> int:
+        def partition(nums, left, right):
+            key = left
+            while left<right:
+                while left<right and nums[key]<=nums[right]:
+                    right-=1
+                while left<right and nums[left]<=nums[key]:
+                    left+=1
+                nums[left], nums[right] = nums[right],nums[left]
+            nums[left], nums[key] = nums[key], nums[left]
+            return left
+
+        def sort(nums, left, right):
+            if left>=right:
+                return
+            mid = partition(nums, left, right)
+            if mid==k:
+                return
+            elif mid<k:
+                sort(nums, mid + 1, right)
+            else:
+                sort(nums, left, mid-1)
+
+        l = len(nums)
+        k = l-k
+        sort(nums, 0, len(nums)-1)
+        return nums[k]
+# leetcode submit region end(Prohibit modification and deletion)

script/[28]实现 strStr().py

@@ -0,0 +1,76 @@
+# 实现 strStr() 函数。 
+# 
+#  给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如
+# 果不存在，则返回 -1 。 
+# 
+#  说明： 
+# 
+#  当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 
+# 
+#  对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：haystack = "hello", needle = "ll"
+# 输出：2
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：haystack = "aaaaa", needle = "bba"
+# 输出：-1
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= haystack.length, needle.length <= 104 
+#  haystack 和 needle 仅由小写英文字符组成 
+#  
+#  Related Topics 双指针 字符串 字符串匹配 
+#  👍 1520 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        def getnext(needle):
+            l = len(needle)
+            ptr1 = 0
+            ptr2 = -1
+            next = [-1] * l #相同前缀长度
+            while ptr1<(l-1):
+                if ptr2==-1 or needle[ptr1] ==needle[ptr2]:
+                    # 每一步更新的是下一个字符的前缀长度
+                    ptr1+=1 #下一个字符
+                    ptr2+=1 # 从哪一个位置开始匹配
+                    next[ptr1] = ptr2
+                else:
+                    # 上一个字符匹配到的位置重新开始匹配
+                    ptr2 = next[ptr2]
+            return next
+        next = getnext(needle)
+        l1 = len(haystack)
+        l2 = len(needle)
+        ptr1 =0
+        ptr2 =0
+        while ptr1<l1 and ptr2 <l2:
+            if ptr2==-1 or haystack[ptr1] == needle[ptr2]:
+                ptr1+=1
+                ptr2+=1
+            else:
+                ptr2 = next[ptr2]
+        if ptr2==l2:
+            return ptr1-ptr2
+        else:
+            return -1
+
+# leetcode submit region end(Prohibit modification and deletion)
+
+

script/[309]最佳买卖股票时机含冷冻期.py

@@ -0,0 +1,58 @@
+# 给定一个整数数组 prices，其中第 prices[i] 表示第 i 天的股票价格 。 
+# 
+#  设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: 
+# 
+#  
+#  卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 
+#  
+# 
+#  注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 
+# 
+#  
+# 
+#  示例 1: 
+# 
+#  
+# 输入: prices = [1,2,3,0,2]
+# 输出: 3 
+# 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出] 
+# 
+#  示例 2:
+
+# 
+#  
+# 输入: prices = [1]
+# 输出: 0
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= prices.length <= 5000 
+#  0 <= prices[i] <= 1000 
+#  
+#  Related Topics 数组 动态规划 
+#  👍 1272 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        #状态买入，T卖出，T-1卖出，T-2卖出
+        l = len(prices)
+        b = [0] * l
+        s1 = [0] * l # 当天卖出
+        s2 = [0] * l # T-1卖出
+        s3 = [0] * l # T-2之前卖出
+        b[0] = -prices[0]
+        for i in range(1, l):
+            b[i] = max(b[i-1], s3[i-1]-prices[i], s2[i-1]-prices[i])
+            s1[i] = b[i-1]+prices[i]
+            s2[i] = s1[i-1]
+            s3[i] = max(s3[i-1], s2[i-1])
+        return max(s1[-1],s2[-1],s3[-1])
+
+
+# leetcode submit region end(Prohibit modification and deletion)

script/[347]前 K 个高频元素.py

@@ -0,0 +1,69 @@
+# 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。 
+# 
+#  
+# 
+#  示例 1: 
+# 
+#  
+# 输入: nums = [1,1,1,2,2,3], k = 2
+# 输出: [1,2]
+#  
+# 
+#  示例 2: 
+# 
+#  
+# 输入: nums = [1], k = 1
+# 输出: [1] 
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= nums.length <= 105 
+#  k 的取值范围是 [1, 数组中不相同的元素的个数] 
+#  题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的 
+#  
+# 
+#  
+# 
+#  进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。 
+#  Related Topics 数组 哈希表 分治 桶排序 计数 快速选择 排序 堆（优先队列） 
+#  👍 1275 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        import collections
+        counter = collections.Counter(nums)
+        counter = list(counter.items())
+
+        def partition(nums, left, right):
+            key= left
+            while left<right:
+                while left<right and nums[key][1]<=nums[right][1]:
+                    right-=1
+                while left<right and nums[key][1]>=nums[left][1]:
+                    left+=1
+                nums[left], nums[right] = nums[right], nums[left]
+            nums[left], nums[key] =nums[key], nums[left]
+            return left
+
+        def sort(nums, k, left, right):
+            if left>=right:
+                return
+            mid = partition(nums, left, right)
+            if mid == k:
+                return
+            elif mid >k:
+                sort(nums, k, left, mid - 1)
+            else:
+                sort(nums, k, mid+1, right)
+
+        l = len(counter)
+        sort(counter, l-k, 0, l-1)
+        return [i[0] for i in counter[-k:]]
+
+
+# leetcode submit region end(Prohibit modification and deletion)

script/[605]种花问题.py

@@ -0,0 +1,60 @@
+# 假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。 
+# 
+#  给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则
+# 的情况下种入 n 朵花？能则返回 true ，不能则返回 false。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：flowerbed = [1,0,0,0,1], n = 1
+# 输出：true
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：flowerbed = [1,0,0,0,1], n = 2
+# 输出：false
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= flowerbed.length <= 2 * 104 
+#  flowerbed[i] 为 0 或 1 
+#  flowerbed 中不存在相邻的两朵花 
+#  0 <= n <= flowerbed.length 
+#  
+#  Related Topics 贪心 数组 
+#  👍 467 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
+        prepos = -1
+        counter = 0
+        l = len(flowerbed)
+        for i in range(l):
+            if flowerbed[i]==1:
+                if prepos<0:
+                    counter += (i-prepos-1)//2
+                else:
+                    counter += (i-prepos-2)//2
+                prepos = i
+        if prepos<0:
+            counter+=(l-prepos)//2
+        else:
+            counter+=(l-prepos-1)//2
+        print(counter)
+        if counter>=n:
+            return True
+        else:
+            return False
+
+
+# leetcode submit region end(Prohibit modification and deletion)