Arrays 检查阵列子阵列的所有元素是否不'；不存在于数组的其余部分中

假设我们有一个数组

a

={…}，我们应该回答一些查询，每个查询包含两个索引

l

和

r

，每个查询的答案是

YES

或

NO

：

是：如果子阵列[l，r]的所有元素不存在于阵列的其余部分（段[1，l-1]和段[r+1，n]）

否：否则

我能提供的最好的方法是o（n^3）解决方案：迭代取o（n^2）的每个段（I，j），然后对每个段检查该段的所有元素，使其总体为o（n^3）

我需要至少O（n^2）解或一些提示，谢谢

例：a=[4， 4, 2, 5. 2, 3] 查询：

1 2->是

3.5->是

2 3->否

---

4 6->NO

预处理：在数组上循环，并创建每个元素的hashmap

计数

，以计算它在数组中出现的频率

对于每个查询：循环子数组并创建一个hashmap

queryCounts

来存储每个元素的计数。在

counts

中查找

queryCounts

的每个元素，并比较计数-如果所有计数都匹配，则返回“是”，否则返回“否”

运行时间：预期的O（n）预处理和每个查询的O（n）

伪代码：

（假设映射中不存在的元素在您尝试访问它们时将被初始化为0，类似于C++的

std:：map

）

预处理：

array[n]//输入数组
映射int>计数
对于i=1到n
计数[数组[i]]++

对于查询

i j

：

Map int>queryCounts
对于x=i到j
查询计数[数组[x]]++
对于查询计数中的每个键y
如果查询计数[y]！=计数[y]
返回“否”
返回“是”

示例：

数组：

[4， 4, 2, 5. 2、3]

hashmap将是：

2->2
3 -> 1
4 -> 2
5 -> 1

如果对子阵列[2,5]进行查询

3 4

（基于1），我们将得到：

2->1
5 -> 1

我们将其与第一个hashmap进行比较，发现

2

的计数不匹配，因此返回“否”

---

---

替代方法：

您还可以在预处理期间循环所有子阵列，并存储是否返回“是”或“否”以获得O（n2）预处理和每个查询的O（1）

请注意，

[i，j]

的hashmap可以从

[i，j-1]

的hashmap中获得，方法是将

数组[j]

的计数加上1，因此，如果我们跟踪错误的计数数，并且只检查如何更改

数组[j]，则在预处理期间我们只需要对每个子数组执行O（1）个工作

的计数将更改此数字

伪代码：

预处理：

array[n]//输入数组
映射字符串>查询结果
对于i=1到n
Map int>queryCounts//在每次迭代时清除
countsWrong=0
对于j=i到n
如果queryCounts[array[j]==counts[array[j]]
countsWrong++//计数匹配，下面的操作将使其不匹配
查询计数[数组[j]]++
如果queryCounts[array[j]==counts[array[j]]
countsWrong--
如果countsWrong==0
queryResults[i，j]=“是”
其他的
查询结果[i，j]=“否”

对于查询

i j

：

返回查询结果[i，j]

示例：

数组：

[4， 4、2]

hashmap将是：

2->1
4 -> 2

我们从i=1，j=1开始：

4->1
countsWrong=1//因为4的计数错误（不是2）
查询结果[1,1]=“否”

对于

i=1，j=2

，我们将1添加到4的计数中：

4->2
countsWrong=0//4的计数现在正确
queryResults[1,2]=“是”

对于

i=1，j=3

，我们将1添加到2的计数中：

4->2
2 -> 1
countsWrong=1//2的计数正确
queryResults[1,3]=“是”

对于

i=2，j=2

，我们将map和1重置为4的计数：

4->1
countsWrong=1//4的计数错误（不是2）
查询结果[2,2]=“否”

对于

i=2，j=3

，我们将1添加到2的计数中：

4->1
2 -> 1
countsWrong=1//2的计数正确，4的计数错误（不是2）
查询结果[2,3]=“否”

对于

i=3，j=3

，我们将map和1重置为2的计数：

2->1
countsWrong=0//2的计数正确
queryResults[1,2]=“是”

预处理：在数组上循环，并创建每个元素的hashmap

计数

，以计算它在数组中出现的频率

对于每个查询：循环子数组并创建一个hashmap

queryCounts

来存储每个元素的计数。在

counts

中查找

queryCounts

的每个元素，并比较计数-如果所有计数都匹配，则返回“是”，否则返回“否”

运行时间：预期的O（n）预处理和每个查询的O（n）

伪代码：

（假设映射中不存在的元素在您尝试访问它们时将被初始化为0，类似于C++的

std:：map

）

预处理：

array[n]//输入数组
映射int>计数
对于i=1到n
计数[数组[i]]++

对于查询

i j

：

Map int>queryCounts
对于x=i到j
查询计数[数组[x]]++
对于查询计数中的每个键y
如果查询计数[y]！=计数[y]
返回“否”
返回“是”

示例：

数组：

[4， 4, 2, 5. 2、3]

hashmap将是：

2->2
3 -> 1
4 -> 2
5 -> 1

如果对子阵列[2,5]进行查询

3 4

（基于1），我们将得到：

2->1
5 -> 1

我们将其与fi进行比较