力扣刷高频面试题（python3）

349.两个数组的交集 【简单】

解法：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]: 
        return list(set(nums1) & set(nums2))
       #return list(set(nums1).intersection(set(nums2)))

53.最大子数组和【中等】

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

解法：

使用动态规划的方法，算法思想：定义状态（子问题），状态转移方程，思考初始值、输出

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        size = len(nums)
        if size == 0:
            return 0
        sub = [0 for _ in range(size)]
        sub[0] = nums[0]
        for i in range(1, size):
            if sub[i-1] >= 0:
                sub[i] = sub[i-1]+nums[i]
            else:
                sub[i] = nums[i]
        maxsub = max(sub)
        return maxsub

 以nums[i]为结尾的子数组和，若以num[i]为结尾的sub[i]大于等于零，则继续加上num[i+1]记作sub[i+1]，最后去找sub数组里最大的值，即最大子数组和。

55.跳跃游戏【中等】​​​​​​​

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

(嘤嘤嘤，解题思路很重要，不然，可能花几个小时整出来的代码还是会有漏算的情况)

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n=len(nums)
        max_i = 0
        for i in range(n):
            if max_i >= i and max_i < i+nums[i]:
                max_i = i+nums[i]
        return max_i >= i

 把能跳到最后一个下标之后的过程分解为：当前下标能跳到的最远处比已知的最远处值要大，且已知的最远处值等于或超过当前下标，则更新最远处的值。遍历所有下标，最终的最远处与最后一个下标相比，大于或等于则表示能够到达最后一个下标！

32. 最长有效括号

 给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        n = len(s)
        dp = [0]*n
        if n == 0:
            return 0
        for i in range(n):
            if i > 0 and s[i] == ')':
                if s[i-1] == ')' and i - dp[i - 1] - 1 >= 0 and s[i - dp[i - 1] - 1] == "(":
                    dp[i] = 2+dp[i-1]+dp[i-dp[i-1]-2]
                elif s[i-1] == '(':
                    dp[i] = 2+dp[i-2]
        return max(dp)               

124. 二叉树中的最大路径和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        def dp(node):
            nonlocal val
            if not node:
                return 0
            left = max(0,dp(node.left))
            right = max(0,dp(node.right))
            lmr = node.val + left + right
            ret = node.val +max(left,right)
            val = max(lmr,val,ret)
            return ret
        val = float('-inf')
        dp(root)
        return val