返回最长上升子序列

最新推荐文章于 2022-12-20 10:22:53 发布

liu_matthew

最新推荐文章于 2022-12-20 10:22:53 发布

阅读量418

点赞数

分类专栏： lintcode测试文章标签： lintcode

本文链接：https://blog.csdn.net/liu_matthew/article/details/56835045

版权

lintcode测试专栏收录该内容

20 篇文章 0 订阅

订阅专栏

返回最长子序列
题目要求：
给定一个整数数组（下标从 0 到 n-1， n 表示整个数组的规模），请找出该数组中的最长上升连续子序列。（最长上升连续子序列可以定义为从右到左或从左到右的序列。）

样例
给定 [5, 4, 2, 1, 3], 其最长上升连续子序列（LICS）为 [5, 4, 2, 1], 返回 4.

给定 [5, 1, 2, 3, 4], 其最长上升连续子序列（LICS）为 [1, 2, 3, 4], 返回 4.

version1:
step1:
先把输入数组当中的后一位数减去前一位数的结果存在一个vector(deviation)中，这样我们就可以通过判断数的正负，从而判断大小序列关系了；
step2:
统计deviation当中连续的序列，最后返回最大值即可；

int LICS(vector<int> & A)
{
    if (A.empty())
    {
        return 0;
    }
    vector<int> deviation;
    for (int i = 1; i < A.size(); i++)
    {
        deviation.push_back(A[i] - A[i - 1]);
    }

    int count_positive = 0;
    vector<int> positive;
    vector<int> negtive;
    int count_negtive = 0;
    for (int i = 0; i < deviation.size(); i++)
    {
        if (deviation[i] < 0)
        {
            if (count_positive != 0)
            {
                positive.push_back(count_positive);
            }
            count_positive = 0;
            count_negtive++;
        }
        if (count_negtive != 0)
        {
            negtive.push_back(count_negtive);
        }
        if (deviation[i] > 0)
        {
            if (count_negtive != 0)
            {
                negtive.push_back(count_negtive);
            }
            count_negtive = 0;
            count_positive++;
        }
        if (count_positive != 0)
        {
            positive.push_back(count_positive);
        }
    }

    vector<int>::iterator biggest_positive = max_element(positive.begin(), positive.end());
    if (biggest_positive != positive.end())
    {
        count_positive = ((*biggest_positive) + 1);
    }


    vector<int>::iterator biggest_negative = max_element(negtive.begin(), negtive.end());
    if (biggest_negative != negtive.end())
    {
        count_negtive = ((*biggest_negative) + 1);
    }
    if (count_positive > count_negtive)
    {
        return count_positive;
    }
    return count_negtive;
}

version2:
通过正向和反向的连续遍历，统计最大上升序列；

public class Solution {
    /**
     * @param A an array of Integer
     * @return  an integer
     */
    public int longestIncreasingContinuousSubsequence(int[] A) {
           int max = 1,count = 1;
           if(A.length <=0){
               return A.length;
           }
           //正向遍历
           for(int i = 1; i<A.length; ){
               while(i<A.length && A[i]>A[i-1] ){
                   i++;
                   count++;
               }if(count > max){
                   max = count;
               }
               count = 1;
               i++;
           }
           //反向遍历
           for(int i = A.length - 1 ; i >= 0; ){
               while(i > 0 && A[i]<A[i-1]  ){
                   i--;
                   count++;
               }if(count > max){
                   max = count;
               }
               count = 1;
               i--;
           }


           return max;

       }
}