[每日leetcode]动态规划的几道题

最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:
可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?
分析：
该位置的最长上升子序列应该等于max{之前他小的值的最长上升子序列+1，初始值}
例如dp[5]=max{1,2+1,2+1}
构出来的dp应该是

10	9	2	5	3	7	101	18
1	1	1	2	2	3	4	4

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        int *dp=new int[n];
        for(int i=0;i<n;i++)
        {
            dp[i]=1;
            for(int j=0;j<i;j++)
            {
                if(nums[i]>nums[j])
                    dp[i]=max(dp[i],dp[j]+1);//该位置处的上升子序列等于该处与之前的上升子序列的较大值
            }
        }
        int result=0;
        for(int i=0;i<n;i++)
        {
            if(result<dp[i])
                result=dp[i];
        }
        return result;
    }
};

最长回文子序列

给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。
示例 1:
输入:
"bbbab"
输出:
4
一个可能的最长回文子序列为 "bbbb"。
示例 2:
输入:
"cbbd"
输出:
2
一个可能的最长回文子序列为 "bb"。

分析：
对于任意字符串，如果头尾字符相同，那么字符串的最长子序列等于去掉首尾的字符串的最长子序列加上首尾；如果首尾字符不同，则最长子序列等于去掉头的字符串的最长子序列和去掉尾的字符串的最长子序列的较大者。
状态转移方程：
dp[i][j]=dp[i-1][j+1] + 2 if（str[i]==str[j]）
dp[i][j]=max(dp[i-1][j],dp[i][j+1]) if （str[i]!=str[j]）

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n=s.length();
        vector<vector<int>> res(n,vector<int>(n,0));
        for(int i=0;i<n;i++)
            res[i][i]=1;//一个字符肯定是
        for(int i=0;i<n;i++)
        {
            for(int j=i-1;j>=0;j--)
            {
                if(s[i]==s[j])
                    res[i][j]=res[i-1][j+1]+2;
                else
                    res[i][j]=max(res[i-1][j],res[i][j+1]);
            }
        }
        return res[n-1][0];
            
    }
};

最长湍流子数组

当 A 的子数组 A[i], A[i+1], …, A[j] 满足下列条件时，我们称其为湍流子数组：
若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；
或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。
也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
返回 A 的最大湍流子数组的长度。

示例 1：
输入：[9,4,2,10,7,8,8,1,9]
输出：5
解释：(A[1] > A[2] < A[3] > A[4] < A[5])
示例 2：
输入：[4,8,12,16]
输出：2
示例 3：
输入：[100]
输出：1

提示：
1 <= A.length <= 40000
0 <= A[i] <= 10^9

分析：如果湍流成立，dp[i] = dp[i-1]+1；否则 如果两数不相等，dp[i] = 2；否则(即两数相等) dp[i] = 1

class Solution {
public:
    int maxTurbulenceSize(vector<int>& A) {
        int n=A.size();
        if(n==1)
            return 1;
        int *dp=new int[n]{1};
        dp[0]=1;
        if(A[1]!=A[0])
            dp[1]=2;
        else
            dp[1]=1;
        int num=max(dp[0],dp[1]);
        for(int i=2;i<n;i++)
        {
            if((A[i-1]>A[i-2]&&A[i-1]>A[i])|| (A[i-1]<A[i-2]&&A[i-1]<A[i]))
            {
                dp[i]=dp[i-1]+1;
                num=max(num,dp[i]);
                    
            }
            else if(A[i-1]!=A[i])
                dp[i]=2;
        }
        return num;
    }
};