基础算法：最长递增子序列

题目描述：

给你一个整数数组nums，找到其中最长严格递增子序列的长度。
nums = [1, 3, 6, 7, 9, 4, 10, 5, 6, 0]

1、方法分析

1. 定义 dp[i]为以nums[i]结尾的最长递增子序列长度。
2. 因为dp[i]以nums[i]结尾，循环遍历i之前的序列0<=j<i;
   如果nums[i]>num[j] => dp[i]=dp[j]+1，否则dp[i]=1(自身)。寻找最大dp[i]。
3. 状态转移方程
   dp[i] = for j in [0,i) max(dp[j]+1, 1)

2、过程分析

[1,3,6,7,9,4,10,5,6,0]
dp[i]定义为以nums[i]结尾的最长递增子序列长度
dp[i] 为 for j=[0,i) if(num[j]<nums[i]) max=dp[j]+1 else max=dp[j]

for i in [0,n] dp[i]=max(dp[j]+1, 1)
i=0 [1,3,6,7,9,4,10,5,6,0] => dp[0]=1
     j(i)
i=1 [1,3,6,7,9,4,10,5,6,0] => dp[1]=for j in[0,1) max(dp[j])=dp[0] dp[1]=dp[0]+1=2
     j i
i=2 [1,3,6,7,9,4,10,5,6,0] => dp[2]=for j in[0,2) max(dp[j])=dp[1] dp[2]=dp[1]+1=3
       j i
i=3 [1,3,6,7,9,4,10,5,6,0] => dp[3]=for j in[0,3) max(dp[j])=dp[2] dp[3]=dp[2]+1=4
         j i
i=4 [1,3,6,7,9,4,10,5,6,0] => dp[4]=for j in[0,4) max(dp[j])=dp[3] dp[4]=dp[3]+1=5
           j i
i=5 [1,3,6,7,9,4,10,5,6,0] => dp[5]=for j in[0,5) max(dp[j])=dp[1] dp[5]=dp[1]+1=3
       j       i
i=6 [1,3,6,7,9,4,10,5,6,0] => dp[6]=for j in[0,6) max(dp[j])=dp[4] dp[6]=dp[4]+1=6
             j    i
i=7 [1,3,6,7,9,4,10,5,6,0] => dp[7]=for j in[0,7) max(dp[j])=dp[5] dp[7]=dp[5]+1=4
               j    i
i=8 [1,3,6,7,9,4,10,5,6,0] => dp[8]=for j in[0,8) max(dp[j])=dp[7] dp[8]=dp[7]+1=5
                    j i
i=9 [1,3,6,7,9,4,10,5,6,0] => dp[9]=for j in[0,9) max(dp[j])=''    dp[9]=1(没有比自身小的元素)
                        j(i)

3、代码

	public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = 1;
        int max = 1;
        for (int i = 1; i < n; i++) {
            int childMax = 1; // 以nums[i]自身结尾 长度最小为1
            for (int j = 0; j < i; j++) { // 取以num[i]结尾 j=0->i中的最长递增子序列 同自身的最大组合
                if (nums[j] < nums[i]) {
                    childMax = Math.max(dp[j] + 1, childMax);
                }
            }
            dp[i] = childMax;
        }
        // 取dp[i]的最大值 也可以设在上述循环中
        for (int i = 0; i < n; i++) {
            max = Math.max(max, dp[i]);
        }
        return max;
    }

4、时间复杂度分析

时间复杂度O(n * n)
空间复杂度O(n)