对于多个查询，查找在 l 到 r 范围内具有相同元素的最长公共子数组

Find the longest common subarray with the same element in range l to r for multiple queries

本文关键字：元素 数组 查找 查询 于多个 范围内      更新时间：2023-10-16

给定一个数组，我们需要找到最长的连续子数组，该子数组在范围 l 到 r 中具有相同的元素以进行多个查询。例如，ar[] = {1,2,2,2,4,3,1,1,3}。

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

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

查询 3：l=6，r=9，元素=3，输出将为 1

查询 4：l=6，r=9，元素=1，输出为 2

我可以运行从 l 到 r 的循环，并计算给定元素在该范围内最长的连续出现，但我需要更好的方法。 约束为 1<=l，r，no。查询数，数组大小<=100000 这是我的蛮力代码：

#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;
}
}

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

这是我的想法(未经测试(。

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(。

相关文章：