update

Author: jasoncao11

72. 背包问题.md

@@ -0,0 +1,26 @@
+***我们有一个背包，背包总的承载重量是 Wkg。现在我们有 n 个物品，每个物品的重量不等，并且不可分割。我们现在期望选择几件物品，装载到背包中。在不超过背包所能装载重量的前提下，如何让背包中物品的总重量最大？***
+
+```
+class Solution:
+    def bag(self, items: List[int], capacity:int) -> List[List[int]]:
+        ind = 0
+        cur = 0
+        max_weight = 0
+        n = len(items)
+        #构造递归
+        def dfs(ind, cur):
+            #递归终止条件
+            if ind == n:
+                if cur > max_weight:
+                    max_weight = cur
+                return
+            #情况1
+            if cur+items[ind] <= capacity:
+                dfs(ind+1, cur+items[ind])
+            #情况2
+            dfs(ind+1, cur)
+        #调用递归
+        dfs(ind, cur)
+        #返回要优化的目标
+        return max_weight
+```

73. 每日温度.md

@@ -0,0 +1,25 @@
+***请根据每日气温列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。***
+
+```
+例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
+```
+
+```
+class Solution(object):
+    def dailyTemperatures(self, temperatures):
+        """
+        :type temperatures: List[int]
+        :rtype: List[int]
+        """
+        #思路：递减栈，遍历整个数组，如果栈不空，且当前数字大于栈顶元素，取出栈顶元素，直接求出下标差就是二者的距离，继续看新的栈顶元素，直到当前数字小于等于栈顶元素停止，然后将数字对应下标入栈，
+        n = len(temperatures)
+        res = [0]*n
+        stack = []
+
+        for i in range(n):
+            while (stack and temperatures[i] > temperatures[stack[-1]]):
+                ind = stack.pop()
+                res[ind] = i - ind
+            stack.append(i)
+        return res
+```

74. 有效的括号.md

@@ -0,0 +1,22 @@
+***给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。***
+
+```
+class Solution:
+    def isValid(self, s: str) -> bool:
+        hashmap = {'(':')','[':']','{':'}'}
+        stack = []
+        
+        for c in s:
+            if c in hashmap:
+                stack.append(c)
+            else:
+                if stack:
+                    top = stack[-1]
+                    if c != hashmap[top]:
+                        return False
+                    else:
+                        stack.pop()
+                else:
+                    return False
+        return not stack
+```

75. 字符串解码.md

@@ -0,0 +1,27 @@
+***输入：s = "3[a]2[bc]" 输出："aaabcbc"***
+
+```
+class Solution(object):
+    def decodeString(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        stack=[]
+        res = ''
+        multi = 0
+
+        for c in s:
+            if '0' <= c <= '9':
+                multi = 10*multi+int(c)
+            elif c == '[':
+                stack.append((res, multi))
+                res = ''
+                multi = 0
+            elif c == ']':
+                last_res, last_multi = stack.pop()
+                res = last_res+res*last_multi
+            else:
+                res += c
+        return res 
+```

76. 栈的压入、弹出序列.md

@@ -0,0 +1,20 @@
+***输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。***
+
+```
+初始化： 辅助栈 stack，弹出序列的索引 i；
+遍历压栈序列： 各元素记为 num；
+元素 num 入栈；
+循环出栈：若 stack 的栈顶元素 == 弹出序列元素 popped[i]，则执行出栈与 i++；
+返回值： 若 stack 为空，则此弹出序列合法。
+
+class Solution:
+    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
+        stack = []
+        i = 0 
+        for num in pushed:
+            stack.append(num)
+            while stack and stack[-1] == popped[i]:
+                stack.pop()
+                i += 1
+        return not stack
+```