Mar.9 最长递增子序列的个数（中等）& 二叉树前中后序和层序遍历（中等）

一、673. 最长递增子序列的个数

一些名词
最长上升子序列(LIS):Longest Increasing Subsequence
最长连续序列(LCS):Longest Consecutive Sequence
最长连续递增序列(LCIS):Longest Continuous Increasing Subsequence
最长公共子序列(LCS): Longest Common Subsequence
最长公共子串（LPS）：Longest Palindromic Substring
这里附上一篇好文：动态规划经典例题——最长公共子序列和最长公共子串（python）

思路

这题是 最长递增子序列的升级版。同样的，用一个dp数组来存放最长递增子序列的长度，这题还需要用一个数组来记录这些序列对应的种数。

# python3
class Solution:
    def findNumberOfLIS(self, nums: List[int]) -> int:
        dp = list()
        count = list()
        if not nums:
            return 0
        for j in range(len(nums)):
            dp.append(1)
            count.append(1)
            for i in range(j):
                if nums[j] > nums[i]:
                    if dp[i] + 1 > dp[j]:
                        dp[j] = dp[i] + 1
                        count[j] = count[i]
                    elif dp[i] + 1 == dp[j]:
                        count[j] += count[i]
        maxlong = max(dp)
        res = 0
        for i in range(len(nums)):
            if dp[i] == maxlong:
                res += count[i]
        return res

二、二叉树前中后序和层序遍历

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
102. 二叉树的层序遍历

前中后序

# python3
# 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 preorder(self, root:TreeNode, res:List) -> List[int]:
        if not root:
            return None
        # 前序
        res.append(root.val)
        self.preorder(root.left, res)
        self.preorder(root.right, res)
        # 中序
        # self.inorder(root.left, res)
        # res.append(root.val)
        # self.inorder(root.right, res)
        # 后序
        #self.postorder(root.left, res)
        #self.postorder(root.right, res)
        #res.append(root.val)

    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = list()
        self.preorder(root, res)
        return res

层序

# python3
# 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 levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = list()
        result = list()
        res.append(root)
        while res:
            n = len(res)
            tmp = list()
            for _ in range(n):
                top = res.pop(0)
                tmp.append(top.val)
                if top.left:
                    res.append(top.left)
                if top.right:
                    res.append(top.right)
            result.append(tmp)
        return result

参考

动态规划解最长子序列子串等一类问题之最长连续递增序列