close

DQUERY - D-query



Given a sequence of n numbers a1, a2 ... an and a number of d-queries. A d-query is a pair (i, j) (1 ≤ i ≤ j ≤ n). For each d-query (i, j), you have to return the number of distinct elements in the subsequence ai, ai+1 ... aj.

Input

  • Line 1: n (1 ≤ n ≤ 30000).
  • Line 2: n numbers a1, a2 ... an (1 ≤ ai ≤ 106).
  • Line 3: q (1 ≤ q ≤ 200000), the number of d-queries.
  • In the next q lines, each line contains 2 numbers i, j representing a d-query (1 ≤ i ≤ j ≤ n).

Output

  • For each d-query (i, j), print the number of distinct elements in the subsequence ai, ai+1 ... aj in a single line.

Example

Input
5
1 1 2 1 3
3
1 5
2 4
3 5

Output
3
2
3 


hide comments
Image manubn: 2026-04-25 09:50:41

It's easily solvable by Implicit Persistent Segment Tree !

Image zahin_420: 2025-12-06 16:59:34

for those who came to this problem through cp-algorithms fenwick tree/BIT page and want hints to solve this problem using BIT:

imagine you have distinct array and ask the same thing that you have to answer how many distinct element there in a range. it is easy right! you would only have to create a BIT array of size n with all 1 in it and answer the queries.

same way how can you make the given array distinct?? you will have to create an BIT array for the given array without duplicates. for example:
array-> 1 1 2 1 3
bit array -> 1 0 1 0 1

as you can see i only consider the leftmost element of every duplicate element. as a result for avobe bit array i can only answer query which left range start at 0. meaning now i have a restriction on in which order i should answer the queries. so a offline problem. :)

Image steve_rogers_1: 2025-04-14 16:31:05

TLE in MO algo java

Image alifahmy1: 2025-02-28 18:18:13

The problem can be reduced to KQUERYO (but instead of elements strictly greater than k like in KQUERYO, you want to find elements strictly less than k) by making new array prev where prev[i] represents the previous index arr[i] occurred at. In the case where it's the first occurrence of arr[i] in the array, you can denote prev[i] with a negative number. Then, it becomes a problem of finding the number of elements in [l, r] such that prev[i] < l, or in other words, you want to count only the first occurrence of each number in [l, r]—If prev[i] > l, then another occurence of it must exist in [l, r], meaning it's a duplicate that shouldn't be counted. This sort of problem is straightforward to solve using a wavelet tree or persistent segment tree.

Alternatively, you can also use Mo's algorithm to solve the queries offline.

KQUERYO: https://www.spoj.com/problems/KQUERYO/

Image undercraft: 2025-02-03 04:20:58

莫队和树没有关系
但这题可以用树
不信去luogu.com看

Image ilhp: 2024-12-15 14:55:27

Using map gives TLE but using a vector of frequencies gives AC.

Image rising_stark: 2024-09-27 12:50:19

One of the worst problems I faced.
After repeated submissions, I was facing TLE. Was optimising the code for no reason, when ultimately it turned out to be an issue of cin vs scanf. Really strict time limit for no reason at all.

Image amira3: 2024-08-10 11:56:28

simple MO algorithm

Image ismaelkno: 2024-03-09 00:14:32

AC IN 1E9+7 LET'S GOOOOOOOOOOOOOOOO!

Image zhouyexuan: 2023-07-27 12:41:32

莫队和树没有关系吧(雾


Added by:Jimmy
Date:2008-10-26
Time limit:1s-1.5s
Source limit:50000B
Memory limit:1536MB
Cluster: Cube (Intel G860)
Languages:All except: ERL JS-RHINO NODEJS PERL6 VB.NET
Resource:Minesweeper