300. 最长递增子序列

我就说我怎么这么轻松做出了dp，原来最优解是贪心+二分，dp只是个O(n^2)的垃圾解法罢了。最长=最优解=dp，重点是不用连续，状态转移方程需要自己推导，dp[i]记录的是以当前为最后一位的最长序列，那么就要遍历i-1，如果前面某个数字比当前数字小，那么就判断dp[i]和dp[j]+1哪个大，每次遍历完，就记录较大的res

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //最长=最优解=dp，可以不用连续
        //状态转移方程，判断
        if(nums.size() == 0) return 0;
        vector<int> dp(nums.size(),1);
        int res = 1;
        for(int i = 1; i < nums.size(); ++i){
            for(int j = 0; j < i; ++j){
                if(nums[i] > nums[j]){
                    dp[i] = max(dp[i],dp[j]+1);
                }
            }
            res = max(dp[i],res);
        }
        return res;
    }
};

一个月后反而不会做了，真是个fw。dp[i]记录的是以当前数字为结尾的最大子序列长度，双重循环，从0遍历到i-1，如果前面的数字比当前数字小，那么就用以它为结尾的子序列长度+1来更新dp[i]。每次看看是否要更新res

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //不用连续
        //可以dfs的一般都可以dp
        //dp[i]表示以当前数字为结尾能达到的最大长度
        //状态转移方程是遍历前面所有数字，如果小于自己，就看看能否更新当前自己的最大长度
        vector<int> dp(nums.size(),1);
        //初始化为1，相当于就是只有自己一个字符的情况
        int res = 1;
        for(int i = 1; i < nums.size(); ++i){
            for(int j = 0;j < i; ++j){
                if(nums[j] < nums[i]){
                    dp[i] = max(dp[i],dp[j]+1);
                }
            }
            res = max(res,dp[i]);
        }
        return res;
    }
};

不想花更多时间来做最优解了，就这样

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //不用连续，最优解=dp
        //状态定义：dp[i]代表的是以当前数字为结尾能达到的最长递增子序列
        //状态转移方程：从0遍历到i-1，如果有个数字小于当前数字，就让dp[i] = max(dp[j]+1,dp[i])
        //初始化：dp[0] = 1，所有位置都初始化为1
        //O(n^2)的时复，如果暴力就是O(2^n)
        vector<int> dp(nums.size(),1);
        int res = 1;
        for(int i = 1; i < nums.size(); ++i){
            for(int j = 0; j < i; ++j){
                if(nums[j] < nums[i]) dp[i] = max(dp[j]+1,dp[i]);
            }
            res = max(res,dp[i]);
        }
        return res;
    }
};

遍历0到i-1，如果nums[j]比自己小，就可以让dp[i] = max(dp[j]+1,dp[i])

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //可以用dp做，dp[i]记录的是以当前数字为结尾能达到的最大递增子序列的长度
        //状态转移:遍历0到i-1，如果nums[j]比自己小，就可以让dp[i] = max(dp[j]+1,dp[i])
        //basecase:dp[i]=1
        vector<int> dp(nums.size(),1);
        int res = 1;
        for(int i = 1; i < nums.size(); ++i){
            for(int j = 0; j < i; ++j){
                if(nums[j] < nums[i]){
                    dp[i] = max(dp[i],dp[j]+1);
                }
            }
            res = max(res,dp[i]);
        }
        return res;
    }
};