2019-06-30

Author: JiayangWu

1103.二叉树寻路/1103-二叉树寻路.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def pathInZigZagTree(self, label):
+        """
+        :type label: int
+        :rtype: List[int]
+        """
+        def findLayer(target, root_val, layer): #找某个label是在第几层
+            if root_val + 2 ** (layer) < target:
+                return findLayer(target, root_val + 2 ** (layer), layer + 1)
+            else:
+                return layer + 1
+        
+        layer = findLayer(label, 1, 1)
+        res = []
+        while label > 1:
+            for i in range(2 ** (layer - 1), 2 **(layer)):
+                if i == label:#在当前层找到了label
+                    idx = i - 2 ** (layer - 1) #label在本层的下标
+                    parentidx = (2 ** (layer - 1) - 1 - idx )// 2 #label的父节点在上一层的下标
+                    # print cnt, parentcnt
+                    break
+            res = [label] + res
+            label = [i for i in range(2 ** (layer - 2), 2 **(layer - 1))][parentidx]
+            layer -= 1
+        return [1] + res

1104.分糖果II/1104-分糖果II.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def distributeCandies(self, candies, n):
+        """
+        :type candies: int
+        :type num_people: int
+        :rtype: List[int]
+        """
+        res = [0 for _ in range(n)]
+        multi = 0
+        while candies > 0:
+            for i in range(len(res)):
+                distri = i + 1 + multi * n
+                if candies > distri:
+                    res[i] += distri
+                    candies -= distri
+                else:
+                    res[i] += candies
+                    candies = 0
+                    break
+            multi += 1
+        return res

1105.填充书架/1105-填充书架.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def minHeightShelves(self, books, shelf_width):
+        """
+        :type books: List[List[int]]
+        :type shelf_width: int
+        :rtype: int
+        """
+        dp = [999999999 for _ in range(len(books) + 1)]
+        dp[0] = 0
+        for i in range(1, len(books) + 1):
+            w, h = 0, 0
+            for j in range(i - 1, -1, -1):
+                w += books[j][0]
+                if w > shelf_width:
+                    break
+                h = max(h, books[j][1])
+                dp[i] = min(dp[i], dp[j] + h)
+        return dp[-1]

1106.解析布尔表达式/1106-解析布尔表达式.py

@@ -0,0 +1,35 @@
+class Solution(object):
+    def parseBoolExpr(self, exp):
+        """
+        :type expression: str
+        :rtype: bool
+        """
+        symbol = []
+        stack = []
+        op = ["|", "&", "!"]
+        
+        for c in exp:
+            if c == "t":
+                stack.append(True)
+            elif c == "f":
+                stack.append(False)
+            elif c in op:
+                symbol.append(c)
+            elif c == ",":
+                continue
+            elif c == "(":
+                stack.append(c)
+            else:
+                o = symbol.pop()
+                tmp = stack[-1]
+                while stack and stack[-1] != "(":
+                    if o == "|":
+                        tmp |= stack.pop()
+                    elif o == "&":
+                        tmp &= stack.pop()
+                    else:
+                        tmp = not stack.pop()
+                stack.pop()
+                stack.append(tmp)
+        # print stack
+        return stack[0]

5035.得分最高的路径/5035-得分最高的路径.py

@@ -17,17 +17,17 @@ def maximumMinimumPath(self, A):
         visited = set([0,0])
         heapify(queue)
         while queue:
-            val, x0, y0 = heappop(queue) #把目前队里最大的点找出来
+            score, x0, y0 = heappop(queue) #把目前队里最优的点找出来
             if [x0, y0] == [m - 1, n - 1]: #如果已经到终点了
-                return -val
+                return -score
 
             for k in range(4):
                 x = x0 + dx[k]
                 y = y0 + dy[k]
 
                 if 0 <= x < m and 0 <= y < n and (x, y) not in visited:
                     visited.add((x, y))
-                    heappush(queue, [max(val, -A[x][y]), x, y]) #邻居入队
+                    heappush(queue, [max(score, -A[x][y]), x, y]) #邻居点入队