算法部分:动态规划

题目:最长增长子序列

class Solution {
    public int lengthOfLIS(int[] nums) {
		if (nums.length==0){
            return 0;
        }
        int[] result = new int[nums.length];
        int max = 0;
        result[0] = 1;
        for (int i = 1; i < nums.length; i++) {
            int index = -1;
            for (int j = 0; j < i; j++) {
                if (nums[j]<nums[i]){
                    if (index==-1){
                        index = j;
                    }
                    else if (result[j]>result[index]){
                        index = j;
                    }
                }

            }
            if (index == -1){
                result[i] = 1;
            }
            else {
                result[i] = result[index]+1;
            }
        }
        for (int i : result) {
            max = Math.max(max,i);
        }
        return max;
    }
}

这个题目是使用动态规划的经典
第 1 步：状态定义。dp[i] 表示以 nums[i] 结尾的最长上升子序列的长度。即：在 [0, …, i] 的范围内，选择以数字 nums[i] 结尾可以获得的最长上升子序列的长度。

说明：以 nums[i] 结尾，是子序列动态规划问题的经典设计状态思路，思想是动态规划的无后效性（定义得越具体，状态转移方程越好推导）。

第 2 步：推导状态转移方程：遍历到 nums[i] 的时候，我们应该把下标区间 [0, … ,i - 1] 的 dp 值都看一遍，如果当前的数 nums[i] 大于之前的某个数，那么 nums[i] 就可以接在这个数后面形成一个更长的上升子序列。把前面的数都看了， dp[i] 就是它们的最大值加 $1$。即比当前数要小的那些里头，找最大的，然后加 $1$ 。

状态转移方程即：dp[i] = max(1 + dp[j] if j < i and nums[j] < nums[i])。

第 3 步：初始化。单独一个数是子序列，初始化的值为 1；

第 4 步：输出。应该扫描这个 dp 数组，其中最大值的就是题目要求的最长上升子序列的长度。