add python solution of contest 140, include 5383, 5084, 5086, 5087.

Author: Mrtj2016

solution/5083.Occurrences After Bigram/Solution.py

@@ -0,0 +1,15 @@
+'''
+分词判断即可
+'''
+
+
+class Solution:
+    def findOcurrences(self, text: str, first: str, second: str) -> List[str]:
+        ls = text.split()
+        loc = 0
+        ans = []
+        while loc < len(ls) - 2:
+            if ls[loc] == first and ls[loc + 1] == second:
+                ans.append(ls[loc + 2])
+            loc += 1
+        return ans

solution/5084.Insufficient Nodes in Root to Leaf Paths/Solution.py

@@ -0,0 +1,47 @@
+'''
+对于每一个node选一条最大的路径，若其和小于limit，则该节点应该被删除。
+'''
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+
+class Solution:
+    def sufficientSubset(self, root, limit: int) -> TreeNode:
+        self.findAns(root, limit, 0)
+        if root.val is None:
+            return None
+        self.trever(root)
+        return root
+
+    def findAns(self, node, limit, presum):
+        '''
+        标记需要删除的节点
+        '''
+        if node is None:
+            return 0
+        left = self.findAns(node.left, limit, presum + node.val)
+        right = self.findAns(node.right, limit, presum + node.val)
+        ret = presum + node.val + max(left, right)
+        if ret < limit:
+            node.val = None
+        return ret - presum
+
+    def trever(self, node):
+        '''
+        删除节点
+        '''
+        if node.left is not None:
+            if node.left.val is None:
+                node.left = None
+            else:
+                self.trever(node.left)
+        if node.right is not None:
+            if node.right.val is None:
+                node.right = None
+            else:
+                self.trever(node.right)

solution/5086.Smallest Subsequence of Distinct Characters/Solution.py

@@ -0,0 +1,41 @@
+'''
+用栈思想。元素在字符串中出现的次数视为元素的可用性。
+从前往后遍历字符串。若当前字符为i，则：
+1、栈为空，i进栈；
+2、若i大于栈顶元素，i进栈；
+3、若i小于栈顶：1）i在栈中出现过一次，i可以性减一；2）进行出栈操作直到栈为空，或栈顶元素可用性为一，或i大于栈顶元素，将i进栈。每个元素出栈则该元素可用性减一。
+栈底到栈定元素次序即为所求。
+'''
+
+
+class Solution:
+    def smallestSubsequence(self, text: str) -> str:
+        dic = {}
+        for i in range(len(text)):
+            if text[i] not in dic:
+                dic[text[i]] = 1
+            else:
+                dic[text[i]] += 1
+        ls = []
+        flag = set()
+        loc = 0
+        while loc < len(text):
+            if len(ls) == 0:
+                ls.append(text[loc])
+                flag.add(text[loc])
+            elif text[loc] in flag:
+                dic[text[loc]] -= 1
+            elif ls[-1] < text[loc]:
+                ls.append(text[loc])
+                flag.add(text[loc])
+            elif ls[-1] >= text[loc]:
+                while len(ls) > 0 and ls[-1] >= text[loc]:
+                    if dic[ls[-1]] == 1:
+                        break
+                    dic[ls[-1]] -= 1
+                    flag.remove(ls[-1])
+                    ls.pop(-1)
+                ls.append(text[loc])
+                flag.add(text[loc])
+            loc += 1
+        return ''.join(ls)

solution/5087.Letter Tile Possibilities/Solution.py

@@ -0,0 +1,19 @@
+'''
+搜索
+'''
+class Solution:
+
+    def numTilePossibilities(self, tiles: str) -> int:
+        dic=set()
+        visit=set()
+        self.dfs(tiles,dic,visit,'')
+        return len(dic)
+
+    def dfs(self,tiles,dic,visit,s):
+        for i in range(len(tiles)):
+            if i not in visit:
+                visit.add(i)
+                if s+tiles[i] not in dic:
+                    dic.add(s+tiles[i])
+                self.dfs(tiles,dic,visit,s+tiles[i])
+                visit.remove(i)