左神中级提升班3(Python)

题目1：

解题思路：创建一个参数count，遍历字符串，当遇到‘（’，count+=1，遇到‘）’，count-=1，取当中的最大值，就是深度。

def num9(s):
    if len(s) == 0: return 0
    count, res = 0, 0
    for i in range(len(s)):
        if s[i] == '(':
            count+=1
        else:
            count-=1
        res = max(res, count)
    return res
s = '((()))'
print('num9:', num9(s))

题目1创新：返回最长的有效括号子串。(子串要连续的) 

解题思路：采用动态规划，创建dp数组，dp[i]表示子串必须以i位置字符结尾的最长有效的长度是多少；当以‘（’结尾时，不可能有效，dp[i]=0，如果以‘）’结尾时，先看他i-1有效字符串前的位置是否为‘（’，如果不是的话，dp[i]=0，是的话就可以串起来形成更长的有效字符串，记录当前位置为pre，如果pre-1>0的话，还需将pre-1的有效字符串长度一起串起来。

def num9dp(s):
    if len(s) == 0: return 0
    # dp[i]表示子串必须以i位置字符结尾的最长有效长度是多少
    dp = [0] * len(s)
    res = 0
    # 0位置的dp绝对是0，所以从1开始
    for i in range(1, len(s)):
        # 当遇到是'('时，dp[i]是0，所以只看右括号结尾的
        if s[i] == ')':
            # pre的位置是dp[i-1]的最长有效长度前的一个位置，看他是否是'('
            pre = i - dp[i-1] - 1
            if pre >= 0 and s[pre] == '(':
                dp[i] = dp[i-1] + 2 + (dp[pre-1] if pre > 0 else 0)
        res = max(res, dp[i])
    return res
s = '(()())()()'
print('num9dp:', num9dp(s))

题目2： 

解题思路：保持辅助栈以相反方向的排序，最后再全部返回到原栈中。 

def num10(stack):
    stack1 = []
    if len(stack) < 2:
        return stack
    while stack:
        if len(stack1) == 0:
            stack1.append(stack.pop())
        # 栈顶的值小于辅助栈顶的值，可以直接移动到辅助栈，保持辅助栈顶到栈尾从小到大的顺序
        if stack[-1] < stack1[-1]:
            stack1.append(stack.pop())
        else:
            k = stack.pop()
            # 不能直接放进去，先把辅助栈中的值移出来，符合条件再放进去
            while stack1 and stack1[-1] < k:
                stack.append(stack1.pop())
            stack1.append(k)
    while stack1:
        stack.append(stack1.pop())
    return stack

# 尾部为栈顶
stack = [6,3,2,4,5]
print(num10(stack))

题目3：

解题思路：

1. 当s[index]=='0'时，返回0
2. 当字符串跑完且超出范围时index==len(s)，返回1
3. 当index后面还有数字字符，有俩种选择：1.将s[index]做为一个字符串，s[index+1]放入递归中；2.将s[index:index+2]做为一个字符串，s[index+2]放入递归中，前提是s[index:index+2]小于27。

def num11(s):
    if len(s) == 0: return 0
    return process(s, 0)
def process(s, index):
    # index跑完时，说明前面是一段有效字符串表达返回1
    if index == len(s): return 1
    # 有‘0’时不可能有效
    if s[index] == '0': return 0
    # index后续还有数字字符的
    # 第一种决定，s[index]做为一个字符串
    res = process(s, index + 1)
    # 当index到最后一位时，返回res
    if index == len(s)-1:
        return res
    # 第二种决定，s[index：index+2]做为一个字符串
    if int(s[index:index+2]) < 27:
        res += process(s, index + 2)
    return res

# 改成动态规划
def num11dp(s):
    # dp[i]表示以i为起点，可以转换的不同字符串的个数
    if not s: return 0
    N = len(s)
    dp = [0]*(N+1)
    dp[N] = 1
    dp[N-1] = 0 if s[N-1]=='0' else 1
    for i in range(N-2, -1, -1):
        if s[i] == '0':
            dp[i] == 0
        else:
            dp[i] = dp[i+1] + (dp[i+2] if int(s[i:i+2]) < 27 else 0)
    return dp[0]

s = '12258'
print(num11(s), num11dp(s))

题目4： 

class Solution(object):
    def maxPath(self,root):
        if not root: return 0
        # 全局变量，只有到达叶节点的时候才会更新
        self.maxSum = float('-inf')
        self.p(root, 0)
        return self.maxSum
    # pre表示从根节点出发到当前节点上方的节点，获得的路径和
    def p(self, x, pre):
        # 当前节点为叶节点
        if not x.left and not x.right:
            self.maxSum = max(self.maxSum, x.val + pre)
        if x.left:
            self.p(x.left, pre + x.val)
        if x.right:
            self.p(x.right, pre + x.val)

root = TreeNode(10)
root.left = TreeNode(2)
root.right = TreeNode(5)
A = Solution()
result = A.maxPath(root)
print(result)