2020-06-29

Author: JiayangWu

1491.去掉最低工资和最高工资后的工资平均值/1491-去掉最低工资和最高工资后的工资平均值.py

@@ -0,0 +1,7 @@
+class Solution(object):
+    def average(self, salary):
+        """
+        :type salary: List[int]
+        :rtype: float
+        """
+        return (sum(salary) - max(salary) - min(salary)) * 1.0 / (len(salary) - 2)

1492.n的第k个因子/1492-n的第k个因子.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def kthFactor(self, n, k):
+        """
+        :type n: int
+        :type k: int
+        :rtype: int
+        """
+        l = []
+        for i in range(1, int(n ** 0.5) + 1):
+            if n % i == 0:
+                l.append(i)
+        total = len(l) * 2 if l[-1] ** 2 != n else len(l) * 2 - 1
+        if total < k:
+            return -1
+        
+        if k - 1 < len(l):
+            return l[k - 1]
+        else:
+            idx = (len(l) - 1) * 2 - k
+            return n // l[idx] if total % 2 else n // l[idx + 2]
+        

1493.删掉一个元素以后全为1的最长子数组/1493-删掉一个元素以后全为1的最长子数组.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def longestSubarray(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if sum(nums) == len(nums):
+            return len(nums) - 1
+        zeroCnt = 0
+        left = 0
+        res = 0
+        for right in range(len(nums)):
+            if nums[right] == 0:
+                zeroCnt += 1
+                while zeroCnt > 1:
+                    if nums[left] == 0:
+                        zeroCnt -= 1
+                    left += 1
+            res = max(res, right - left + 1 - zeroCnt)
+        return res
+                    

1494.并行课程II/1494-并行课程II.py

@@ -0,0 +1,49 @@
+class Solution(object):
+    def minNumberOfSemesters(self, n, dependencies, k):
+        """
+        :type n: int
+        :type dependencies: List[List[int]]
+        :type k: int
+        :rtype: int
+        """
+        from collections import defaultdict
+        inDegree = defaultdict(int)
+        outDegree = defaultdict(int)
+        children = defaultdict(set)
+        
+        for src, dec in dependencies: # 建图
+            inDegree[dec] += 1
+            outDegree[src] += 1
+            children[src].add(dec)
+            
+        queue = []
+        for i in range(1, n + 1):
+            if inDegree[i] == 0: # 入度为0（没有先修课了）的课入队
+                heappush(queue, (-outDegree[i], i, -1)) # 出度越大（以这门课作为先修课的课越多），优先级越高 
+        
+        semesterCnt = 0
+        while queue:
+            semesterCnt += 1
+            nextSemesterCourses = [] # 存放这个学期不能上的课
+            courseCnt = 0
+            while courseCnt < k and queue: # 每个学期最多上 k 门课
+                priority, node, preFinishedSemester = heappop(queue)
+
+                if preFinishedSemester >= semesterCnt: # 当前学期不能上这门课
+                    nextSemesterCourses.append((priority, node, preFinishedSemester))
+                    continue
+                    
+                for child in children[node]: # 这门课可以学，学它，然后处理孩子课的入度
+                    inDegree[child] -= 1
+                    
+                    if inDegree[child] == 0: # 孩子课的先修课全上完了
+                        heappush(queue, (-outDegree[child], child, semesterCnt))
+                courseCnt += 1
+                
+            for item in nextSemesterCourses: # 把之前存起来的本学期不能上的课再重新入队
+                heappush(queue, item)
+
+        return semesterCnt
+                
+                
+                    

1496.判断路径是否相交/1496-判断路径是否相交.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def isPathCrossing(self, path):
+        """
+        :type path: str
+        :rtype: bool
+        """
+        s = set([(0, 0)])
+        x, y = 0, 0
+        for d in path:
+            if d == "N":
+                y += 1
+            elif d == "S":
+                y -= 1
+            elif d == "E":
+                x += 1
+            elif d == "W":
+                x -= 1
+            if (x, y) in s:
+                return True
+            s.add((x, y))
+        return False
+                

1497.检查数组对是否可以被k整除/1497-检查数组对是否可以被k整除.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def canArrange(self, arr, k):
+        """
+        :type arr: List[int]
+        :type k: int
+        :rtype: bool
+        """
+        from collections import defaultdict
+        dic = defaultdict(int)
+        for num in arr:
+            mod = num % k
+            if mod:
+                dic[mod] += 1
+        for key in dic.keys():
+            if key * 2 != k and dic[key] != dic[k - key]:
+                return False
+            if key * 2 == k and dic[key] % 2 != 0:
+                return False
+        return True
+             

1498.满足条件的子序列数目/1498-满足条件的子序列数目.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def numSubseq(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        nums.sort()
+        left, right = 0, len(nums) - 1
+        res = 0
+        MOD = 10 ** 9 + 7
+        while left <= right:
+            s = nums[left] + nums[right]
+            l = right - left
+            if s <= target:
+                res = (res + (1 << l)) % MOD
+                left += 1
+            else:
+                right -= 1
+        return res

1499.满足不等式的最大值/1499-满足不等式的最大值.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def findMaxValueOfEquation(self, points, k):
+        """
+        :type points: List[List[int]]
+        :type k: int
+        :rtype: int
+        """
+        from collections import deque
+        queue = deque([(points[0][0], points[0][0] - points[0][1])])
+        res = float("-inf")
+        for yi, yj in points[1:]:
+            while queue and queue[0][0] < yi - k:
+                queue.popleft()
+            if queue:
+                res = max(res, -queue[0][1] + yi + yj)
+            sub = yi - yj
+            while queue and queue[-1][1] > sub:
+                queue.pop()
+            queue.append((yi, sub))
+        return res