leetcode-300. 最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

class Solution {
    public int lengthOfLIS(int[] nums) {
            int[] dp = new int[nums.length];
            dp[0] = 1;
            Arrays.fill(dp,1);
            int res = 0;
            if (nums == null) return 0;
            for(int i = 0;i<nums.length;i++){
                for(int j=0;j<i;j++){
                    if(nums[j]<nums[i]){
                          dp[i] = Math.max(dp[j]+1,dp[i]);  
                    }
                }
                res = Math.max(res,dp[i]);
            }
            return res;
    }
}

---

这道题目的问题是求一个整数数组的最长上升子序列的长度。解决这个问题的一个有效方法是使用动态规划。

动态规划的基本思想是将问题分解为相互重叠的子问题，并存储子问题的解，避免重复计算。

1. 定义状态量：在这个问题中，我们可以定义一个状态dp[i]，表示在nums数组中，以nums[i]为结尾的最长递增子序列的长度。
2. 寻状态方程：对于每一个元素nums[i]（i从1开始，到nums.length-1结束），再遍历它之前的所有元素nums[j]（j从0开始，到i-1结束）。如果nums[i] > nums[j]，说明nums[i]可以接在以nums[j]为结尾的上升子序列后面，形成一个更长的上升子序列。所以，我们更新dp[i]为dp[j]+1和dp[i]的较大值。
3. 初始化：首先，我们初始化一个长度等于数组长度的dp数组，并将所有元素设为1。因为任何一个元素都可以形成长度为1的上升子序列。同时判断数组为空的情况。
4. 遍历顺序：

• 外层遍历的顺序是从左到右： 这是因为我们在计算每一个dp[i]时，需要使用到dp[j]（j<i）的结果。因此，我们需要先计算dp[j]，再计算dp[i]。这就需要我们从左到右遍历数组。、
• 内层遍历的顺序可以从左到右，也可以从右到左：

  在这个问题中，内层遍历的目的是找出索引小于i（即j < i）的所有元素j，使得nums[j]小于nums[i]，并且dp[j]尽可能地大。遍历的顺序并不影响这个目标的达成。

  因此，理论上来说，内层遍历是可以从右到左进行的，即从i-1开始，到0结束。但是这并不会带来任何性能上的优势，因为我们无论如何都需要遍历i之前的所有元素。实际上，从左到右的遍历顺序在理解和实现上可能更直观和简单。

  这是因为在大多数动态规划问题中，我们都习惯于从小到大遍历状态，因为小的状态常常是计算大的状态所必需的。如果改为从大到小遍历，可能会让人感到困惑，尤其是在复杂的动态规划问题中。

      5.打印：在这个问题的上下文中，变量res用于存储当前找到的最长递增子序列的长度。在每次遍历时，我们都会比较res和dp[i]的值，并将它们中的最大值赋给res。这样，res始终保持了当前找到的最长递增子序列的长度。

tips：

Q:在这个动态规划问题中，每个dp[i]代表的是在nums数组中，以nums[i]为结尾的最长递增子序列的长度。计算dp[i]时，我们需要考虑所有的j < i，并在nums[i]大于nums[j]的情况下对dp[i]进行更新。为什么要这样做呢？

A:如果nums[j] < nums[i]，那么nums[i]可以接在以nums[j]为结尾的递增子序列后面，形成一个更长的递增子序列。在这种情况下，以nums[i]为结尾的最长递增子序列的长度可以是dp[j] + 1，因为我们在长度为dp[j]的子序列后面添加了一个元素。

但是，dp[i]可能已经被之前的j更新过了，也就是说，可能存在一个k < j，使得nums[k] < nums[i]并且dp[k] + 1 > dp[j] + 1。在这种情况下，如果我们直接让dp[i] = dp[j] + 1，就会错过以nums[k]为结尾的那个更长的子序列。

因此，我们需要在dp[j] + 1和当前的dp[i]之间取较大值，确保dp[i]始终表示的是以nums[i]为结尾的最长递增子序列的长度。