为多个查询查找 l 到 r 范围内具有相同元素的最长公共子数组答案

【问题标题】：Find the longest common subarray with the same element in range l to r for multiple queries为多个查询查找 l 到 r 范围内具有相同元素的最长公共子数组
【发布时间】：2020-02-18 04:10:11
【问题描述】：

给定一个数组，我们需要在 l 到 r 范围内为多个查询找到最长的连续子数组。例如，ar[] = {1,2,2,2,4,3,1,1,3}。

查询 1：l=1，r=5，元素=2，输出为 3

查询 2：l=1,r=5, element=1, 输出为 1

查询 3：l=6,r=9, element=3, 输出为 1

查询 4：l=6,r=9, element=1, 输出为 2

我可以运行从 l 到 r 的循环并计算给定元素在该范围内的最长连续出现，但我需要更好的方法。约束是 1

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
int main()
{
    ll i,j,k,m,n,l,r,x;
    n=9;
    ll ar[n]={1,2,2,2,4,3,1,1,3};
    ll query=4;//number of queries
    while(query--)
    {
        cin>>l>>r>>x;
        l--;r--;//changing to 0-based indexing
        ll ctr=0;
        ll ans=0;
        for(i=l;i<=r;i++)
        {
            if(ar[i]==x)
            {
                ctr++;
            }
            else ctr=0;
            ans=max(ctr,ans);
        }
        cout<<ans<<endl;
    }
}

【问题讨论】：

这不是问题，是命令。
引用：“可以运行循环......但我需要更好的方法。”你是怎么得出这个结论的？
“我可以运行从 l 到 r 的循环并计算给定元素在该范围内的最长连续出现”，请显示该代码，理想情况下为 minimal reproducible example。 “但我需要更好的方法”，为什么？这是因为How to Ask。
我已按要求添加了之前的代码。

标签： c++ arrays algorithm data-structures segment-tree

【解决方案1】：

这个问题可以用段树来解决。

这是我的想法（未经测试）。

struct Node {
    // Length of this segment.
    int len;

    // Value and length of the longest prefix subarray.
    int prefix_val;
    int prefix_len;

    // Value and length of the longest suffix subarray.
    int suffix_val;
    int suffix_len;

    // Value and length of the longest subarray in this segment.
    int best_len;
    int best_val;
};

// Combines two nodes.
Node combine(Node lhs, Node rhs) {
    Node res;
    res.len = lhs.len + rhs.len;

    // Compute new best prefix subarray.
    res.prefix_val = lhs.prefix_val;
    res.prefix_len = lhs.prefix_len;
    if (lhs.prefix_len == lhs.len &&
        lhs.prefix_val == rhs.prefix_val) {
        res.prefix_len = lhs.len + rhs.prefix_len;
    }

    // Compute new best suffix subarray.
    res.suffix_val = rhs.suffix_val;
    res.suffix_len = rhs.suffix_len;
    if (rhs.suffix_len == rhs.len &&
        rhs.suffix_val == lhs.suffix_val) {
        res.suffix_len = rhs.len + lhs.suffix_len;
    }
    res.best_val = lhs.best_val;
    res.best_len = lhs.best_len;
    if (res.best_len < rhs.best_len) {
        res.best_val = rhs.best_val;
        res.best_len = rhs.best_len;
    }
    if (res.best_len < res.prefix_len) {
        res.best_val = res.prefix_val;
        res.best_len = res.prefix_len;
    }
    if (res.best_len < res.suffix_len) {
        res.best_val = res.suffix_val;
        res.best_len = res.suffix_len;
    }

    // Middle subarray.
    if (lhs.suffix_val == rhs.prefix_val) {
        int len = lhs.suffix_len + rhs.prefix_len;
        if (res.best_len < len) {
            res.best_val = val;
            res.best_len = len;
        }
    }
    return res;
}

每个查询的复杂度为 O(logN)。

【讨论】：