new

Author: sunriseXu

121. Best Time to Buy and Sell Stock.py

@@ -0,0 +1,26 @@
+# You are given an array prices where prices[i] is the price of a given stock on the ith day.
+
+# You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+
+# Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+
+ 
+
+# Example 1:
+
+# Input: prices = [7,1,5,3,6,4]
+# 1 10 9 8 2 0 18
+# Output: 5
+# Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+# Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        current = prices[0]
+        profit = 0
+        for i in prices[1:]:
+            if current > i:
+                current = i
+            profit = max(profit, i - current)
+        return profit
+        
+        

122. Best Time to Buy and Sell Stock II.py

@@ -0,0 +1,36 @@
+# You are given an integer array prices where prices[i] is the price of a given stock on the ith day.
+
+# On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. However, you can buy it then immediately sell it on the same day.
+
+# Find and return the maximum profit you can achieve.
+
+ 
+
+# Example 1:
+
+# Input: prices = [7,1,5,3,6,4]
+# Output: 7
+# Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+# Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+# Total profit is 4 + 3 = 7.
+class Solution:
+    def maxProfit(self, prices):
+        totalProfit = 0
+        profit = 0
+        current = prices[0]
+        last = current
+        for i in prices[1:]:
+            if current > i or last > i:
+                current = i
+                totalProfit += profit
+                profit = 0
+                
+            profit = max(profit, i - current)
+            last = i
+        totalProfit += profit
+        return totalProfit
+
+sol = Solution()
+res = sol.maxProfit([1,2,3,4,5,6])
+print(res)
+                

134.GasStation.py

@@ -0,0 +1,40 @@
+class Solution(object):
+    def canCompleteCircuit(self, gas, cost):
+        '''
+        gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+        if you start from a, and stuck at b, then you can't start from any station between a and b.
+        也就是说排除法，走过的路如果不通，那么中间的任何一条路都不通
+        '''
+        # start from 0, find first stuck station
+        start = 0
+        fly = 0
+        while True:
+            # find next stuck point
+            i = start 
+            current = gas[i]
+            flag = 0
+            init = True
+            while init or i != start:
+                init = False
+                current = current - cost[i]
+                if current < 0:
+                    # stuck , break
+                    if start + 1 >= len(gas):
+                        return -1
+                    start = (i+1) % len(gas)
+                    flag = 1
+                    break
+                i = (i+1) % len(gas)
+                if i + 1 >= len(gas):
+                    fly = 1
+                current = current + gas[i]
+                
+            if flag == 0:
+                # find answer
+                return start
+            if flag == 1 and fly == 1:
+                return -1
+
+s = Solution()
+res = s.canCompleteCircuit(gas = [4,5,2,6,5,3], cost = [3,2,7,3,2,9])
+print(res)

15.3sum.py

@@ -0,0 +1,49 @@
+class Solution(object):
+    def threeSum(self, nums):
+        '''
+        nums: List[int]
+        rtype: List[List[int]]
+        Input: nums = [-1,0,1,2,-1,-4]
+        Output: [[-1,-1,2],[-1,0,1]]
+        在一个数组中，找到三个数，相加等于0。穷尽所有组合。
+        如果使用暴力遍历的方式，那么需要遍历数组三次。复杂度太高。
+        1. 首先对数组进行排序
+        2. 然后从两端开始进行筛选,但是如何对两端进行移动呢，无法解决这一问题
+        3. 同时移动，还是只移动一端，如何判断移动哪一端？
+        
+        解答：
+        1. 固定一端，然后对其他两端进行twosum
+        
+        该算法用途：
+        用于配对问题上，例如那几个物体结合起来能达到特定效果，这和硬币DP问题有什么区别？
+        硬币问题是硬币个数无限以及结合的数量并非固定
+        '''
+        res = []
+        nums2 = sorted(nums)
+        
+        for i in range(len(nums2) - 2):
+            if i > 0 and nums2[i] == nums2[i-1]:
+                continue
+            if nums2[i] > 0:
+                continue
+            j = i + 1
+            k = len(nums2) - 1
+            total = 0 - nums2[i]
+            while j < k:
+                tmp = nums2[j] + nums2[k] 
+                if tmp < total:
+                    j += 1
+                elif tmp > total:
+                    k -= 1
+                else:
+                    res.append([nums2[i], nums2[j], nums2[k]])
+                    j += 1
+                    while nums2[j] == nums2[j-1] and j < k:
+                        j += 1
+        return res
+        
+        
+            
+s = Solution()
+res = s.threeSum([-1,0,1,2,-1,-4])
+print(res)

189. Rotate Array.py

@@ -0,0 +1,30 @@
+# Given an integer array nums, rotate the array to the right by k steps, where k is non-negative.
+
+ 
+
+# Example 1:
+
+# Input: nums = [1,2,3,4,5,6,7], k = 3
+# Output: [5,6,7,1,2,3,4]
+# Explanation:
+# rotate 1 steps to the right: [7,1,2,3,4,5,6]
+# rotate 2 steps to the right: [6,7,1,2,3,4,5]
+# rotate 3 steps to the right: [5,6,7,1,2,3,4]
+
+class Solution(object):
+    def rotate(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: None Do not return anything, modify nums in-place instead.
+        """
+        total = len(nums)
+        k = k % total
+        if k == 0:
+            return nums
+        nums[0: k], nums[k:-1] = nums[k:-1], nums[0: k]
+        return nums
+    
+sol = Solution()
+res = sol.rotate(nums = [1,2,3,4,5,6,7], k = 3)
+print(res)

209.MinimumSizeSubarraySum.py

@@ -0,0 +1,37 @@
+class Solution(object):
+    def minSubArrayLen(self, target, nums):
+        '''
+            固定数组，找一个长度最小的subarray,元素之和大于或等于某target
+            [2,3,1,2,4,3] 7 -> [4,3] -> len 2
+            注意是subarray而不是subset
+            [1,4,4] 4 -> [4] -> len 1
+            
+            滑动窗口，不觉得像蜗牛吗，固定序列的顺序，找子序列的问题
+            如果窗口合适，那记录下来，然后继续往前走
+        '''
+        i = 0
+        j = 0
+        minLen = float("inf")
+        total = nums[0]
+        while j < len(nums):
+            if total >= target:
+                minLen = min(minLen, j- i + 1)
+                total -= nums[i]
+                i += 1
+                if i > j:
+                    j += 1
+                    if j > len(nums) - 1:
+                        break
+                    total += nums[j]
+            else:
+                j += 1
+                if j > len(nums) - 1:
+                    break
+                total += nums[j]
+        if minLen == float("inf"):
+            minLen = 0
+        return minLen
+    
+s = Solution()
+res = s.minSubArrayLen(7, [2,3,1,2,4,3])
+print(res)

274.H-Index.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def hIndex(self, citations):
+        """
+        :type citations: List[int]
+        :rtype: int
+        """
+        # sort the cite
+        citations.sort()
+        m = len(citations)
+        hindex = 0
+        for i in range(m-1, -1, -1):
+            if citations[i] >= m - i:
+                hindex = m -i 
+        return hindex
+    
+s = Solution()
+res = s.hIndex([3,0,6,1,5])
+print(res)
+
+
+# [4]
+# 0 1 2 6 7 8
+
+

30.SubstringwithConcatenationofAllWords.py

@@ -0,0 +1,34 @@
+from collections import deque, Counter
+
+class Solution:
+   def findSubstring(self, s: str, words: list[str]) -> list[int]:
+        words_counter = Counter(words)
+        words_len = len(words)
+        word_len = len(words[0])
+        final_list = []
+        def single_slice(start):
+            counter = Counter()
+            word_queue = deque([], words_len)
+            start_list = []
+            for i in range(start, len(s), word_len):
+                word = s[i:i+word_len]
+                if word not in words:
+                    counter.clear()
+                    word_queue.clear()
+                    continue
+                counter[word] += 1
+                word_queue.append((i, word))
+                if counter == words_counter:
+                    start_list.append(word_queue[0][0])
+                if len(word_queue) == words_len:
+                    counter[word_queue[0][1]] -= 1
+            return start_list
+        
+        for i in range(word_len):
+            final_list.extend(single_slice(i))
+        return final_list
+
+
+s = Solution()
+res = s.findSubstring("barfoothefoobarman", ["foo","bar"])
+print(res)

452.MinimumNumberofArrowstoBurstBalloons.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def findMinArrowShots(self, points):
+        """
+        :type points: List[List[int]]
+        :rtype: int
+        """
+        points.sort(key=lambda x: x[0])
+        # sorted
+        current = 0
+        largest = points[0][1]
+        count = 0
+        
+        while current < len(points):
+            current += 1
+            if largest >= points[current][0]:
+                if largest < points[current][1]:
+                    largest = points[current][1]
+            else:
+                count += 1
+        return count
+            
+s = Solution()
+res = s.findMinArrowShots([[10,16],[2,8],[1,6],[7,12]])
+print(res)

55.JumpGame.py

@@ -0,0 +1,62 @@
+class Solution(object):
+    def canJump(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        给一个序列，每个元素代表从该元素能够跳的最长距离，从第一个元素开始，判断是否能跳到最后一个元素
+        从最后的元素开始往前数，能到达该元素的最远元素A选择为下一个节点。为什么一定要选择最远的元素。
+        假设选择的并非最远的元素B，那么，元素A必然能够到达元素B，然后是元素C在A之前跳过A直接到达B。
+        那么从元素C必然也能够达到元素A。
+        """
+        current = len(nums) - 1
+        if current == 0:
+            return 0
+        count = 0
+        while True:
+            i = current 
+            step = 0
+            # flag = 0
+            while i >= 0:
+                i -= 1
+                if i < 0:
+                    break
+                step += 1
+                if nums[i] < step:
+                    continue
+                current = i
+                # flag = 1 
+            count += 1
+            
+            if current == 0:
+                return count
+    def canJump2(self, nums):
+        """
+        这里采用最近原则，因为考虑到全部元素都为1的情况，这种是最坏情况，时间复杂度为n方
+        因此只选择第一个能够到达的元素进行遍历
+        """
+        current = len(nums) - 1
+        if current == 0:
+            return True
+        while True:
+            i = current 
+            step = 0
+            flag = 0
+            while i >= 0:
+                i -= 1
+                if i < 0:
+                    break
+                step += 1
+                if nums[i] < step:
+                    continue
+                current = i
+                flag = 1 
+                break
+            if flag == 0:
+                return False
+            if current == 0:
+                return True
+        
+ 
+s = Solution()
+res = s.canJump2([0])
+print(res)