lintcode longest-increasing-continuous-subsequence 最长上升连续子序列

最新推荐文章于 2023-09-01 12:41:13 发布

原创最新推荐文章于 2023-09-01 12:41:13 发布 · 682 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#lintcode #动态规划

lintcode 同时被 2 个专栏收录

49 篇文章

订阅专栏

动态规划

19 篇文章

订阅专栏

本文探讨了两种求解最长连续递增子序列(LICS)的方法。第一种方法使用动态规划，通过数组记录以每个元素结尾的LICS长度。第二种方法简化了计算过程，分别跟踪递增和递减序列的最大长度，并返回两者之间的较大值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述

lintcode

笔记

假设buff[i]的含义是，从第0到第i个数的序列中，以第i个数为结尾的LICS的长度。（代码1）
九章算法的解法是，分别计算递增和递减的LICS长度，最后取大者，比我的解法简单。（代码2）

代码1

class Solution {
public:
    /**
     * @param A an array of Integer
     * @return  an integer
     */
    int longestIncreasingContinuousSubsequence(vector<int>& A) {
        // Write your code here
        const int len = A.size();
        if (len == 1)
            return 1;
        if (len == 2)
            return 2;
        int buff[len];
        buff[0] = 1;
        buff[1] = 2;
        for (int i = 2; i < len; i++)
        {
            if (A[i-2] < A[i-1])
            {
                if (A[i-1] < A[i])
                {
                    buff[i] = buff[i-1] + 1;
                }
                else
                {
                    buff[i] = 2;
                }
            }
            else 
            {
                if (A[i-1] > A[i])
                {
                    buff[i] = buff[i-1] + 1;
                }
                else
                {
                    buff[i] = 2;
                }
            }
        }
        int res = buff[0];
        for (int i = 1; i < len; i++)
            res = max(res, buff[i]);
        return res;
    }

};

代码2

class Solution {
public:
    /**
     * @param A an array of Integer
     * @return  an integer
     */
    int longestIncreasingContinuousSubsequence(vector<int>& A) {
        // Write your code here
        if (A.empty())
            return 0;
        int nasc = 1;
        int ndesc = 1;
        int max_nasc = 1;
        int max_ndesc = 1;
        for (int i = 1; i < A.size(); i++)
        {
            if (A[i-1] < A[i])
            {
                nasc++;
                max_ndesc = max(max_ndesc, ndesc);
                ndesc = 1;
            }
            else
            {
                ndesc++;
                max_nasc = max(max_nasc, nasc);
                nasc = 1;
            }
        }
        max_ndesc = max(max_ndesc, ndesc);
        max_nasc = max(max_nasc, nasc);
        return max(max_ndesc, max_nasc);
    }
};