给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

对原数组 nums 去重并排序，存储在数组 sorted_nums 中，并求sorted_nums与nums的最长公共子序列，这即是最长递增子序列

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n=len(nums)
        if n==1:
            return 1
        # 将原问题转化为求最长公共子序列
        sorted_nums = sorted(list(set(nums)))
        return self.longestCommonSubsequence(nums,sorted_nums)
        
    # 求最长公共子序列    
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        n, m = len(text1), len(text2)
        dp = [[0]*(m+1) for _ in range(n + 1)]
        for i in range(n):
            for j in range(m):
                if text1[i]==text2[j]:
                    dp[i+1][j+1]=dp[i][j]+1
                else:
                    dp[i+1][j+1]=max(dp[i][j + 1], dp[i + 1][j])
        return dp[n][m]

你打算构建一些障碍赛跑路线。给你一个 下标从 0 开始 的整数数组 obstacles ，数组长度为 n ，其中 obstacles[i] 表示第 i 个障碍的高度。
对于每个介于 0 和 n - 1 之间（包含 0 和 n - 1）的下标 i ，在满足下述条件的前提下，请你找出 obstacles 能构成的最长障碍路线的长度：
你可以选择下标介于 0 到 i 之间（包含 0 和 i）的任意个障碍。
在这条路线中，必须包含第 i 个障碍。
你必须按障碍在 obstacles 中的 出现顺序 布置这些障碍。
除第一个障碍外，路线中每个障碍的高度都必须和前一个障碍 相同 或者 更高 。
返回长度为 n 的答案数组 ans ，其中 ans[i] 是上面所述的下标 i 对应的最长障碍赛跑路线的长度。

该题就是求以每个数结尾的最长上升子序列，对示例返回值稍作修改直接调用

func longestObstacleCourseAtEachPosition(obstacles []int) []int {
    return lengthOfIS(obstacles)
}
func lengthOfIS(nums []int)[]int{
    n:=len(nums)
    dp:=make([]int,n)
    for i:=0;i<n;i++{
        dp[i]=1
    }
    for i:=0;i<n;i++{
        for j:=0;j<i;j++{
            if nums[j]<=nums[i]{
                dp[i]=max(dp[i],dp[j]+1)
            }
        }
    }
    return dp
}
func max(a,b int)int{if a>b{return a};return b}

给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。
当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。
请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。
注意：不允许旋转信封。

本题可以看做就是二维层面的最长递增问题，只需要在判断是否满足递增时注意判断宽度与高度是否都满足条件即可。

其次，需要注意本题不需要满足套娃的信封是子序列，即信封的顺序可以改变，因此我们可以在求最长递增之前将二维数组按某一维进行升序排列，这样就可以直接套用最长递增子序列的求解思路。

func maxEnvelopes(envelopes [][]int) int {
    n := len(envelopes)
    dp := make([]int, n)
    for i := 0; i < n; i++ {
        dp[i] = 1 // 初始值为 1（每个信封自身也算一个 LIS）
    }
    // 按照宽度升序排序，若宽度相同则按照高度升序排序
    sort.Slice(envelopes, func(i, j int) bool {
        if envelopes[i][0] == envelopes[j][0] {
            return envelopes[i][1] < envelopes[j][1]
        }
        return envelopes[i][0] < envelopes[j][0]
    })
    // 计算 LIS 长度
    for i := 1; i < n; i++ {
        for j := 0; j < i; j++ {
            if envelopes[j][0] < envelopes[i][0] && envelopes[j][1] < envelopes[i][1] {
                dp[i] = max(dp[i], dp[j]+1)
            }
        }
    }
    // 取 dp 数组的最大值作为答案
    return max(dp...)
}
func max(nums ...int) int {
    // 不定参数函数，返回所有参数中的最大值
    res := nums[0]
    for _, num := range nums[1:] {
        if num > res {
            res = num
        }
    }
    return res
}

假设你是球队的经理。对于即将到来的锦标赛，你想组合一支总体得分最高的球队。球队的得分是球队中所有球员的分数 总和 。
然而，球队中的矛盾会限制球员的发挥，所以必须选出一支 没有矛盾 的球队。如果一名年龄较小球员的分数 严格大于 一名年龄较大的球员，则存在矛盾。同龄球员之间不会发生矛盾。
给你两个列表 scores 和 ages，其中每组 scores[i] 和 ages[i] 表示第 i 名球员的分数和年龄。请你返回 所有可能的无矛盾球队中得分最高那支的分数 。

此题与上题类似，也是二维的最长递增子序列问题，按照分数从小到大排序，分数相同的按照年龄从小到大排序，之后计算所有位置的最长递增子序列。
不过此题的状态转移方程有所不同，为$$dp[i]=max(dp[j])+scores[i]$$

\func bestTeamScore(scores []int, ages []int) int {
    n := len(scores)
    dp := make([]int, n) // dp[i] 表示前 i 个球员中，最后一个球员年龄为 i 时的得分最大值
    ballplayer := make([][]int, n) // 将每个球员的分数和年龄组成二元组，用于排序
    for i := 0; i < n; i++ {
        ballplayer[i] = []int{scores[i], ages[i]} // 初始化二元组
    }
    // 按照分数升序排序，若分数相同则按照年龄升序排序
    sort.Slice(ballplayer, func(i, j int) bool {
        if ballplayer[i][0] == ballplayer[j][0] {
            return ballplayer[i][1] < ballplayer[j][1]
        }
        return ballplayer[i][0] < ballplayer[j][0]
    })
    // 计算所有以当前位置为结尾的最大得分
    for i := 0; i < n; i++ {
        for j := 0; j < i; j++ {
            // 如果第 j 名球员的年龄不超过第 i 名球员，则可以将第 i 名球员加入到以第 j 名球员结尾的最优子序列中
            if ballplayer[j][1] <= ballplayer[i][1] {
                dp[i] = max(dp[i], dp[j])
            }
        }
        dp[i] += ballplayer[i][0] // 加上第 i 名球员的得分
    }
    // 返回所有最大得分中的最大值
    return max(dp...)
}

func max(nums ...int) int {
    // 不定参数函数，返回所有参数中的最大值
    res := nums[0]
    for _, num := range nums[1:] {
        if num > res {
            res = num
        }
    }
    return res
}

给你 n 个长方体 cuboids ，其中第 i 个长方体的长宽高表示为 cuboids[i] = [widthi, lengthi, heighti]（下标从 0 开始）。请你从 cuboids 选出一个 子集 ，并将它们堆叠起来。
如果 widthi <= widthj 且 lengthi <= lengthj 且 heighti <= heightj ，你就可以将长方体 i 堆叠在长方体 j 上。你可以通过旋转把长方体的长宽高重新排列，以将它放在另一个长方体上。
返回 堆叠长方体 cuboids 可以得到的 最大高度 。

此题与上题类似，不过是三维的最长递增子序列问题，且本题的三个维度可以相互转变。
因此我们首先将每个立方体的长、宽、高都按从小到大的顺序排列，并且按照边长从小到大排列所有立方体，之后按照求解最长递增子序列的思路来求该题的最高高度。

func maxHeight(cuboids [][]int) (ans int) {
    // 将每个立方体的长、宽、高从小到大排序
    for _, c := range cuboids {
        sort.Ints(c)
    }
    // 将立方体按照边长排序
    sort.Slice(cuboids, func(i, j int) bool {
        a, b := cuboids[i], cuboids[j]
        return a[0] < b[0] || a[0] == b[0] && (a[1] < b[1] || a[1] == b[1] && a[2] < b[2])
    })
    //经过以上处理保证了每个立方体的长、宽、高都按从小到大的顺序排列，并且按照边长从小到大排列所有立方体
    
    // dp[i] 表示选取第 i 个立方体作为堆栈底部时，可以构成的最大高度
    dp := make([]int, len(cuboids))
    for i, c2 := range cuboids {
        for j, c1 := range cuboids[:i] {
            if c1[1] <= c2[1] && c1[2] <= c2[2] {  // 满足垒叠条件，则更新状态
                dp[i] = max(dp[i], dp[j]) // c1 可以堆在 c2 上
            }
        }
        dp[i] += c2[2]  // c2 的高度加上上面堆起来的立方体的高度，就是总高度
        ans = max(ans, dp[i]) // 更新最大高度
    }
    return
}
func max(a,b int)int{if a>b{return a};return b}

给定一个未排序的整数数组 nums ， 返回最长递增子序列的个数 。
注意 这个数列必须是 严格 递增的。

• 定义 dp[i] 表示以第 i 个元素为结尾的最长上升子序列的长度，求解过程与上题一样。
• 同时定义 cnt[i] 表示以第 i 个元素为结尾的最长上升子序列的数量（可能包含多个）。
• 遍历 nums 数组，对于每个位置 i 和其前面的位置 j，如果当前元素 nums[i] 大于 nums[j]，则可以将 nums[i] 加入以 nums[j] 结尾的 LIS 中。此时比较 dp[i] 和 dp[j]+1 的大小：如果 dp[j]+1 大于 dp[i]，说明以 j 结尾的 LIS 加上 num[i] 更优，则更新 dp[i] 和 cnt[i]；如果 dp[j]+1 等于 dp[i]，则说明多了一个以 i 结尾的 LIS，则仅更新 cnt[i]（不更新 dp[i]），且注意更新 cnt[i]时都是加上cnt[j]，而不是1。
• 遍历 dp 数组，计算最大的 dp[i] 值作为整个数组的 LIS 长度，并统计拥有该长度的最长上升子序列的数量之和。

func findNumberOfLIS(nums []int) int {
    n := len(nums)
    // 初始化动态规划数组和计数数组，长度均为 n
    dp := make([]int, n) // dp[i] 表示以 nums[i] 结尾的最长递增子序列长度
    cnt := make([]int, n) // cnt[i] 表示以 nums[i] 结尾且长度为 dp[i] 的递增子序列数量
    for i := 0; i < n; i++ {
        dp[i] = 1 // 初始值为 1（每个数自身也算一个 LIS）
        cnt[i] = 1 // 初始值为 1，表示单独一个数也构成一个长度为 1 的 LIS
    }
    // 计算所有以当前位置为结尾的递增子序列
    for i := 0; i < n; i++ {
        for j := 0; j < i; j++ {
            if nums[j] < nums[i] {
                // 如果可以将 nums[i] 接在 nums[j] 后面形成一个更长的递增子序列，
                // 则更新 dp[i] 并将 cnt[i] 设为 cnt[j]，即以 nums[j] 结尾的递增子序列可以延续到 nums[i]
                if dp[j]+1 > dp[i] {
                    dp[i] = dp[j] + 1
                    cnt[i] = cnt[j]
                } else if dp[j]+1 == dp[i] {
                    // 如果接上 nums[i] 后仍然是 dp[i] 长度的递增子序列，则将以 nums[j] 结尾的递增子序列数量累加到 cnt[i]
                    cnt[i] += cnt[j]
                }
            }
        }
    }
    // 找到最长递增子序列的长度和数量
    maxLen := 0 // 最长递增子序列的长度
    res := 0 // 最长递增子序列的数量
    for i := 0; i < n; i++ {
        if dp[i] > maxLen {
            maxLen = dp[i]
            res = cnt[i]
        } else if dp[i] == maxLen {
            res += cnt[i]
        }
    }
    return res
}

func max(a, b int) int {if a > b { return a}; return b}

我们定义 arr 是 山形数组 当且仅当它满足：
arr.length >= 3
存在某个下标 i （从 0 开始） 满足 0 < i < arr.length - 1 且：
arr[0] < arr[1] < … < arr[i - 1] < arr[i]
arr[i] > arr[i + 1] > … > arr[arr.length - 1]
给你整数数组 nums​ ，请你返回将 nums 变成 山形状数组 的​ 最少 删除次数。

使用最长递增子序列（LIS）的方法来解决得到山形数组的最少删除次数问题，可以先将该问题转化为求最长的单峰子序列长度。

具体地，我们可以对于原山形数组，将其分为左右两个方向，每个部分都计算出最长递增子序列（LIS），分别用left[i]表示原数组的前i个元素的最长递增子序列长度，right[i]表示原数组的后n-i个元素的最长递减子序列长度（即将原数组反转后求得）。然后，对于一个山形数组，可以确定一个峰值，使得左半部分的LIS和右半部分的LIS能够在这个峰值处拼接成为单峰子序列。

那么，我们可以枚举峰值的位置（注意峰值需要满足不在第一个或最后一个位置，且左、右的最长递增子序列长度都大于1），分别计算其左右部分的LIS，并将它们相加作为单峰子序列的长度。最终，我们可以取所有可能峰值位置所得长度中的最大值即为所求的最短删除次数。

func minimumMountainRemovals (nums []int) int {
    n := len(nums)
    left, right := make([]int, n), make([]int, n)
    // 计算左半部分最长递增子序列
    for i := range nums {
        left[i] = 1
        for j := 0; j < i; j++ {
            if nums[j] < nums[i] {
                left[i] = max(left[i], left[j]+1)
            }
        }
    }
    // 计算右半部分最长递增子序列
    for i := n - 1; i >= 0; i-- {
        right[i] = 1
        for j := n - 1; j > i; j-- {
            if nums[j] < nums[i] {
                right[i] = max(right[i], right[j]+1)
            }
        }
    }
    ans := 0
    // 枚举峰值位置，且峰值不能在第一个或者最后一个位置，计算单峰子序列长度
    for i := 1; i < n-1; i++ {
        //只有当左、右的最长递增子序列长度都大于1时，当前节点才能作为峰值
        if left[i] > 1 && right[i] > 1 {
        ans = max(ans, left[i]+right[i]-1)
        }
    }
    return n - ans
}
func max(a, b int) int {if a > b {return a};return b
}