Merge branch 'master' of https://github.com/JiayangWu/LeetCode-Python

Author: Jiayang Wu

0392.判断子序列/0392-判断子序列.py

@@ -0,0 +1,13 @@
+class Solution(object):
+    def isSubsequence(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        i, j = 0, 0
+        while i < len(s) and j < len(t):
+            if s[i] == t[j]:
+                i += 1
+            j += 1
+        return i == len(s)

0477.汉明距离总和/0477-汉明距离总和.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def totalHammingDistance(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums:
+            return 0
+        res = 0
+        mask = 1
+        for i in range(32):
+            cnt_one = 0
+            for num in nums:
+                cnt_one += 1 if num & mask else 0 
+                
+            res += cnt_one * (len(nums) - cnt_one)
+            mask = mask << 1
+        return res
+        
+                

0543.二叉树的直径/0543-二叉树的直径.py

@@ -0,0 +1,26 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def diameterOfBinaryTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        self.res = 0
+        def height(node):
+            if not node:
+                return 0
+            left_h = height(node.left)
+            right_h = height(node.right)
+            
+            self.res = max(self.res, left_h + right_h) 
+            return 1 + max(left_h, right_h)
+        height(root)
+        return self.res

0646.最长数对链/0646-最长数对链.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def findLongestChain(self, pairs):
+        """
+        :type pairs: List[List[int]]
+        :rtype: int
+        """
+        pairs = sorted(pairs, key = lambda x: x[1])
+        
+        end = pairs[0][0] - 1
+        res = 0
+        for pair in pairs:
+            if pair[0] > end:
+                res += 1
+                end = pair[1]
+        
+        return res

0792.匹配子序列的单词数/0792-匹配子序列的单词数.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def numMatchingSubseq(self, S, words):
+        """
+        :type S: str
+        :type words: List[str]
+        :rtype: int
+        """
+        from collections import defaultdict
+        
+        dic = defaultdict(list)
+        for i, ch in enumerate(S):
+            dic[ch].append(i)
+            
+        res = 0
+        for word in words:
+            pre = -1
+            flag = True
+            for i, ch in enumerate(word):
+                l = dic[ch]
+                # 在l找第一个比pre大的元素
+                idx = bisect.bisect(l, pre)
+                
+                if idx == len(l):# 没找到
+                    flag = False
+                    break
+                pre = l[idx]
+                
+            if flag:
+                res += 1
+
+        return res

1180.统计只含单一字母的子串/1180-统计只含单一字母的子串.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def countLetters(self, S):
+        """
+        :type S: str
+        :rtype: int
+        """
+        res = 0
+        for i in range(len(S)):
+            for j in range(i + 1, len(S) + 1):
+                substring = S[i:j]
+                if substring == substring[0] * len(substring):
+                    res += 1
+                    # print substring
+        return res

1192.查找集群内的「关键连接」/1192-查找集群内的「关键连接」.py

@@ -0,0 +1,41 @@
+from collections import defaultdict
+class Solution(object):
+    def criticalConnections(self, n, connections):
+        """
+        :type n: int
+        :type connections: List[List[int]]
+        :rtype: List[List[int]]
+        """
+        visited = set()
+        low = [9999999] * n
+        discover = [999999] * n
+        parent = [-1] * n
+ 
+        graph = defaultdict(list)
+        self.time = 0
+        res = []
+        for u, v in connections:
+            graph[u].append(v)
+            graph[v].append(u)
+        
+        def dfs(u):
+            visited.add(u)
+            discover[u] = self.time
+            low[u] = self.time
+            self.time += 1
+ 
+            for v in graph[u]:
+                if v not in visited:
+                    parent[v] = u
+                    dfs(v)
+                    low[u] = min(low[u], low[v])
+ 
+                    if low[v] > discover[u]:
+                        res.append([u, v])
+                elif v != parent[u]:
+                    low[u] = min(low[u], discover[v])
+                
+        for i in range(n):
+            if i not in visited:
+                dfs(i)
+        return res

1207.独一无二的出现次数/1207-独一无二的出现次数.py

@@ -0,0 +1,8 @@
+class Solution(object):
+    def uniqueOccurrences(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: bool
+        """
+        d = collections.Counter(arr)
+        return len(d.values()) == len(set(d.values()))

1213.三个有序数组的交集/1213-三个有序数组的交集.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def arraysIntersection(self, arr1, arr2, arr3):
+        """
+        :type arr1: List[int]
+        :type arr2: List[int]
+        :type arr3: List[int]
+        :rtype: List[int]
+        """
+        res = []
+        record = [0 for _ in range(2005)]
+        for num in arr1 + arr2 + arr3:
+            record[num] += 1
+        
+        for i in range(len(record)):
+            if record[i] == 3:
+                res.append(i)
+                
+        return res

1221.分割平衡字符串/1221-分割平衡字符串.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def balancedStringSplit(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        if not s:
+            return 0
+        # print s
+        l, r = 0, 0
+        
+        for i in range(len(s)):
+            if s[i] == "R":
+                r += 1
+            else:
+                l += 1
+            # print r, l
+            if l == r:
+                return 1 + self.balancedStringSplit(s[i + 1:])
+            
+        return 0

1228.等差数列中缺失的数字/1228-等差数列中缺失的数字.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def missingNumber(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: int
+        """
+        d = (arr[-1] - arr[0]) // len(arr)
+        
+        k = arr[0]
+        for num in arr:
+            if num != k:
+                return k
+            k += d
+        return k

1229.安排会议日程/1229-安排会议日程.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def minAvailableDuration(self, slots1, slots2, duration):
+        """
+        :type slots1: List[List[int]]
+        :type slots2: List[List[int]]
+        :type duration: int
+        :rtype: List[int]
+        """
+        slots1 = sorted(slots1, key = lambda x:x[0])
+        slots2 = sorted(slots2, key = lambda x:x[0])
+        slots = []
+        i, j = 0, 0
+        while i < len(slots1) and j < len(slots2):
+            if slots1[i][1] < slots2[j][0]:
+                i += 1
+                continue
+            elif slots1[i][0] > slots2[j][1]:
+                j += 1
+                continue
+            start = max(slots1[i][0], slots2[j][0])
+            end = min(slots1[i][1], slots2[j][1])
+            slots.append([start, end])
+            i += 1
+                
+        print(slots)
+        for start, end in slots:
+            if end - start >= duration:
+                return [start, start + duration]
+        return []
+        
+        

1230.抛掷硬币/1230-抛掷硬币.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def probabilityOfHeads(self, prob, target):
+        """
+        :type prob: List[float]
+        :type target: int
+        :rtype: float
+        """
+        dp = [0 for _ in range(len(prob) + 1)]
+        dp[1] = prob[0]
+        dp[0] = 1 - prob[0]
+        for i in range(1, len(prob)):
+            new_dp = [0 for _ in range(len(prob) + 1)]
+            for j in range(target + 1):
+                new_dp[j] = dp[j] * (1 - prob[i]) + dp[j - 1] * prob[i]
+            dp = new_dp[:]
+        return dp[target]
+    
+        # dp = [[0 for _ in range(len(prob) + 1)] for _ in range(len(prob))]
+        # # dp[i][j] 表示前i个硬币里，有j个硬币正面朝上的概率
+        # dp[0][1] = prob[0]
+        # dp[0][0] = 1 - prob[0]
+        # for i, p in enumerate(prob):
+        #     for j in range(target + 1):
+        #         if i > 0:
+        #             dp[i][j] += dp[i - 1][j] * (1 - p)
+        #             dp[i][j] += dp[i - 1][j - 1] * (p)
+        # return dp[-1][target]

1231.分享巧克力/1231-分享巧克力.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def maximizeSweetness(self, sweetness, K):
+        """
+        :type sweetness: List[int]
+        :type K: int
+        :rtype: int
+        """
+        if not K:
+            return sum(sweetness)
+        left, right = 0, sum(sweetness) // K
+        res = 0
+        while left <= right:
+            mid = (left + right) // 2
+            cnt = 0
+            tmp = 0
+            for s in sweetness:
+                if tmp + s > mid:
+                    cnt += 1
+                    tmp = 0
+                else:
+                    tmp += s
+            
+            if cnt < K + 1:
+                right = mid - 1
+            else:
+                left = mid + 1
+        return left

1232.缀点成线/1232-缀点成线.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def checkStraightLine(self, coordinates):
+        """
+        :type coordinates: List[List[int]]
+        :rtype: bool
+        """
+        c = sorted(coordinates, key = lambda x:x[0])
+        k = None
+        for i in range(len(c)):
+            if i:
+                x0, y0 = c[i - 1][0], c[i - 1][1]
+                x1, y1 = c[i][0], c[i][1]
+            
+                if x0 == x1:
+                    return False
+                new_k = 1.0 * (y1 - y0) / (x1 - x0)
+                if k and k != new_k:
+                    return False
+                k = new_k
+            
+        return True
+        

1243.数组变换/1243-数组变换.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def transformArray(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: List[int]
+        """
+        flag = 1
+        while flag:
+            flag = 0
+            res = [num for num in arr]
+            for i in range(1, len(arr) - 1):
+                if arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:
+                    res[i] -= 1
+                    flag = 1
+                elif arr[i - 1] > arr[i] and arr[i] < arr[i + 1]:
+                    res[i] += 1
+                    flag = 1
+            arr = res[:]
+        return res
+