LeetCode 978 很好的DP问题

最新推荐文章于 2022-01-28 20:07:01 发布

原创最新推荐文章于 2022-01-28 20:07:01 发布 · 427 阅读

0 ·

CC 4.0 BY-SA版权

dp 专栏收录该内容

18 篇文章

订阅专栏

比赛的时候写的O(n^2)的解法，代码如下

class Solution {
public:
    int maxTurbulenceSize(vector<int>& A) {
        //区间dp问题,naive方法是遍历所有区间，然后逐一进行检查并找出最优解
        //然而本问题具有最优子结构，所以可以利用dp进行推导
        int res = 1;
        int n = A.size();
        //vector<vector<int>> dp(2,vector<int>(n,1));   //最小的长度一定是1
        vector<int> pre(n,1);   //len-1
        vector<int> cur(n,1);   //len
        for(int len=2;len<=n;len++){
            for(int i=0;i<=n-len;i++){
                int j = i+len-1;   //cur len : len
                if(pre[i+1]==len-1){
                    if(A[i+1]<A[i+2] && A[i]>A[i+1]){
                        // dp[i][j] = j-i+1;
                        cur[i] = len;
                    }
                    else if(A[i+1]>A[i+2] && A[i]<A[i+1]){
                        // dp[i][j] = j-i+1;
                        cur[i] = len;
                    }
                }
                if(pre[i]==len-1){
                    if(A[j-2]<A[j-1] && A[j-1]>A[j]){
                        // dp[i][j] = j-i+1;
                        cur[i] = len;
                    }
                    else if(A[j-2]>A[j-1] && A[j-1]<A[j]){
                        // dp[i][j] = j-i+1;
                        cur[i] = len;
                    }
                }
            }
            for(int i=0;i<n;i++){
                pre[i] = cur[i];
                res = max(res,pre[i]);
                cur[i] = 1;
            }
            if(res != len)
                break;
        }
//         for(int len=2;len<=n;len++){    //长度
//             for(int i=0;i<=n-len;i++){  //起点
//                 int j = i+len-1;  //终点
//                 //判断dp[i][j]是否的最大长度是多小，取决于dp[i-1][j]和dp[i][j-1]是否是可满足的
//                 if(dp[i+1][j] == j-i){  //若是可满足的，考虑是否可以进行扩展
//                     if(A[i+1]<A[i+2] && A[i]>A[i+1]){
//                         dp[i][j] = j-i+1;
//                     }
//                     else if(A[i+1]>A[i+2] && A[i]<A[i+1]){
//                         dp[i][j] = j-i+1;
//                     }
//                 }
//                 if(dp[i][j-1] == j-i){
//                     if(A[j-2]<A[j-1] && A[j-1]>A[j]){
//                         dp[i][j] = j-i+1;
//                     }
//                     else if(A[j-2]>A[j-1] && A[j-1]<A[j]){
//                         dp[i][j] = j-i+1;
//                     }
//                 }
                
//                 res = max(res,dp[i][j]);
//             }
//         }
        return res;
    }
};

后来看题解写的O(n)的解法，很巧妙

class Solution {
public:
    int maxTurbulenceSize(vector<int>& A) {
        int n = A.size();
        int res = 1;
        int pre = 0;
        int left,right;
        for(int i=1;i<n;i++){
            if(A[i-1]<A[i])   //increase or decrease
                left = 1;
            else if(A[i-1]>A[i])
                left = -1;
            else
                left = 0;
            if(i<n-1){
                if(A[i]<A[i+1])
                    right = 1;
                else if(A[i]>A[i+1])
                    right = -1;
                else
                    right = 0;
            }
            else{
                right = 0;
            }
            if(i==n-1 || left*right!=-1){
                res = max(res,i-pre+1);
                pre = i;     //why not start over
            }
        }
        return res;
    }
};