Longest monotonous consequent sub-sequence

Problem: Find out the longest continuous sub-sequence.

Analysis:

This is a canonical solution. Runing from the ledt side of the given sequence, if the i+1th element is bigger or equal to the ith one, add to a temporary vector. Otherwise, the i+1th element will not increase the length of the current stored sub-sequence. Then, compare the temporary vector with the returned vector, replace the returned vector with the temporary one.

The time complexity is O(n).

Solutions:

C++:

vector<int> longest_monotonous_sequence(int seq[], int n, bool isIncreased = true)
{
    vector<int> lms;
    if(n == 0)
        return lms;

    vector<int> temp_mon_seq;
    for(int i = 0; i < n; ++i) {
        if(temp_mon_seq.empty())
            temp_mon_seq.push_back(seq[i]);
        else {
            if(isIncreased) {
                if(seq[i] >= *(temp_mon_seq.end() - 1))
                    temp_mon_seq.push_back(seq[i]);
                else {
                    if(temp_mon_seq.size() > lms.size())
                        lms = temp_mon_seq;
                    temp_mon_seq.clear();
                }
            } else {
                if(seq[i] <= *(temp_mon_seq.end() - 1))
                    temp_mon_seq.push_back(seq[i]);
                else {
                    if(temp_mon_seq.size() > lms.size())
                        lms = temp_mon_seq;
                    temp_mon_seq.clear();
                }
            }
        }
    }

    if(temp_mon_seq.size() > lms.size())
        lms = temp_mon_seq;

    return lms;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
This problem can be solved using a sliding window approach. We will maintain a window of indices [left, right] such that the sub-array A[left, right] contains at most K distinct elements. We will also maintain a hash table to keep track of the count of each element in the current window. Initially, left = 1, right = 1, and the hash table is empty. We will iterate over the array A from left to right and for each element A[right], we will update the hash table and the number of distinct elements in the current window. If the number of distinct elements is greater than K, we will move the left pointer to the right and update the hash table and the number of distinct elements accordingly. We will continue this process until the number of distinct elements is less than or equal to K. We will keep track of the maximum length of the sub-array found so far and the corresponding indices. At the end, we will output the indices of the longest sub-array found. Here's the Python code that implements this approach: ```python n, k = map(int, input().split()) a = list(map(int, input().split())) left = right = 0 count = {} max_len = 0 max_indices = (1, 1) while right < n: # Update count of current element count[a[right]] = count.get(a[right], 0) + 1 # Update number of distinct elements while len(count) > k: count[a[left]] -= 1 if count[a[left]] == 0: del count[a[left]] left += 1 # Update maximum sub-array length if right - left + 1 > max_len: max_len = right - left + 1 max_indices = (left, right+1) right += 1 print(max_indices[0], max_indices[1]) ``` This code has a time complexity of O(n) and a space complexity of O(k).
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值