Given an array ‘a[]’ of size n and number of queries q. Each query can be represented by two integers l and r. Your task is to print the number of distinct integers in the subarray l to r.

Given a[i] <=

Examples :

Input : a[] = {1, 1, 2, 1, 2, 3} q = 3 0 4 1 3 2 5 Output : 2 2 3 In query 1, number of distinct integers in a[0...4] is 2 (1, 2) In query 2, number of distinct integers in a[1..3] is 2 (1, 2) In query 3, number of distinct integers in a[2..5] is 3 (1, 2, 3) Input : a[] = {7, 3, 5, 9, 7, 6, 4, 3, 2} q = 4 1 5 0 4 0 7 1 8 output : 5 4 6 7

Let a[0…n-1] be input array and q[0..m-1] be array of queries.**Approach :**

- Sort all queries in a way that queries with L values from 0 to
are put together, then all queries from to , and so on. All queries within a block are sorted in increasing order of R values. - Initialize an array freq[] of size
with 0 . freq[] array keep count of frequencies of all the elements in lying in a given range. - Process all queries one by one in a way that every query uses number of different elements and frequency array computed in previous query and stores the result in structure.

- Let ‘curr_Diff_element’ be number of different elements of previous query.
- Remove extra elements of previous query. For example if previous query is [0, 8] and current query is [3, 9], then remove a[0], a[1] and a[2]
- Add new elements of current query. In the same example as above, add a[9].

**Adding elements()**

- Increase the frequency of element to be added(freq[a[i]]) by 1.
- If frequency of element a[i] is 1.Increase curr_diff_element by 1 as 1 new element has been added in range.

**Removing elements() **

- Decrease frequency of element to be removed (a[i]) by 1.
- if frequency of an element a[i] is 0.Just decrease curr_diff_element by 1 as 1 element has been completely removed from the range.

**Note : ** In this algorithm, in step 2, index variable for R change at most O(n *

The preprocessing part takes O(m Log m) time.

Processing all queries takes O(n * **Below is the implementation of above approach :**

`// Program to compute no. of different elements ` `// of ranges for different range queries ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `// Used in frequency array (maximum value of an ` `// array element). ` `const` `int` `MAX = 1000000; `
` ` `// Variable to represent block size. This is made ` `// global so compare() of sort can use it. ` `int` `block; `
` ` `// Structure to represent a query range and to store ` `// index and result of a particular query range ` `struct` `Query { `
` ` `int` `L, R, index, result; `
`}; ` ` ` `// Function used to sort all queries so that all queries ` `// of same block are arranged together and within a block, ` `// queries are sorted in increasing order of R values. ` `bool` `compare(Query x, Query y) `
`{ ` ` ` `// Different blocks, sort by block. `
` ` `if` `(x.L / block != y.L / block) `
` ` `return` `x.L / block < y.L / block; `
` ` ` ` `// Same block, sort by R value `
` ` `return` `x.R < y.R; `
`} ` ` ` `// Function used to sort all queries in order of their ` `// index value so that results of queries can be printed ` `// in same order as of input ` `bool` `compare1(Query x, Query y) `
`{ ` ` ` `return` `x.index < y.index; `
`} ` ` ` `// calculate distinct elements of all query ranges. ` `// m is number of queries n is size of array a[]. ` `void` `queryResults(` `int` `a[], ` `int` `n, Query q[], ` `int` `m) `
`{ ` ` ` `// Find block size `
` ` `block = (` `int` `)` `sqrt` `(n); `
` ` ` ` `// Sort all queries so that queries of same `
` ` `// blocks are arranged together. `
` ` `sort(q, q + m, compare); `
` ` ` ` `// Initialize current L, current R and current `
` ` `// different elements `
` ` `int` `currL = 0, currR = 0; `
` ` `int` `curr_Diff_elements = 0; `
` ` ` ` `// Initialize frequency array with 0 `
` ` `int` `freq[MAX] = { 0 }; `
` ` ` ` `// Traverse through all queries `
` ` `for` `(` `int` `i = 0; i < m; i++) { `
` ` ` ` `// L and R values of current range `
` ` `int` `L = q[i].L, R = q[i].R; `
` ` ` ` `// Remove extra elements of previous range. `
` ` `// For example if previous range is [0, 3] `
` ` `// and current range is [2, 5], then a[0] `
` ` `// and a[1] are subtracted `
` ` `while` `(currL < L) { `
` ` ` ` `// element a[currL] is removed `
` ` `freq[a[currL]]--; `
` ` `if` `(freq[a[currL]] == 0) `
` ` `curr_Diff_elements--; `
` ` ` ` `currL++; `
` ` `} `
` ` ` ` `// Add Elements of current Range `
` ` `// Note:- during addition of the left `
` ` `// side elements we have to add currL-1 `
` ` `// because currL is already in range `
` ` `while` `(currL > L) { `
` ` `freq[a[currL - 1]]++; `
` ` ` ` `// include a element if it occurs first time `
` ` `if` `(freq[a[currL - 1]] == 1) `
` ` `curr_Diff_elements++; `
` ` ` ` `currL--; `
` ` `} `
` ` `while` `(currR <= R) { `
` ` `freq[a[currR]]++; `
` ` ` ` `// include a element if it occurs first time `
` ` `if` `(freq[a[currR]] == 1) `
` ` `curr_Diff_elements++; `
` ` ` ` `currR++; `
` ` `} `
` ` ` ` `// Remove elements of previous range. For example `
` ` `// when previous range is [0, 10] and current range `
` ` `// is [3, 8], then a[9] and a[10] are subtracted `
` ` `// Note:- Basically for a previous query L to R `
` ` `// currL is L and currR is R+1. So during removal `
` ` `// of currR remove currR-1 because currR was `
` ` `// never included `
` ` `while` `(currR > R + 1) { `
` ` ` ` `// element a[currL] is removed `
` ` `freq[a[currR - 1]]--; `
` ` ` ` `// if occurrence of a number is reduced `
` ` `// to zero remove it from list of `
` ` `// different elements `
` ` `if` `(freq[a[currR - 1]] == 0) `
` ` `curr_Diff_elements--; `
` ` ` ` `currR--; `
` ` `} `
` ` `q[i].result = curr_Diff_elements; `
` ` `} `
`} ` ` ` `// print the result of all range queries in ` `// initial order of queries ` `void` `printResults(Query q[], ` `int` `m) `
`{ ` ` ` `sort(q, q + m, compare1); `
` ` `for` `(` `int` `i = 0; i < m; i++) { `
` ` `cout << ` `"Number of different elements"` `<< `
` ` `" in range "` `<< q[i].L << ` `" to "` ` ` `<< q[i].R << ` `" are "` `<< q[i].result << endl; `
` ` `} `
`} ` ` ` `// Driver program ` `int` `main() `
`{ ` ` ` `int` `a[] = { 1, 1, 2, 1, 3, 4, 5, 2, 8 }; `
` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); `
` ` `Query q[] = { { 0, 4, 0, 0 }, { 1, 3, 1, 0 }, `
` ` `{ 2, 4, 2, 0 } }; `
` ` `int` `m = ` `sizeof` `(q) / ` `sizeof` `(q[0]); `
` ` `queryResults(a, n, q, m); `
` ` `printResults(q, m); `
` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

**Output:**

Number of different elements in range 0 to 4 are 3 Number of different elements in range 1 to 3 are 2 Number of different elements in range 2 to 4 are 3

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Count of odd and even parity elements in subarray using MO's algorithm
- Longest subarray not having more than K distinct elements
- Maximum distinct prime factors of elements in a K-length subarray
- Queries for number of distinct elements in a subarray | Set 2
- Maximize the subarray sum after multiplying all elements of any subarray with X
- Maximum length of subarray such that all elements are equal in the subarray
- Number of elements less than or equal to a number in a subarray : MO's Algorithm
- Maximum Subarray Sum using Divide and Conquer algorithm
- Range Queries for count of Armstrong numbers in subarray using MO's algorithm
- Karatsuba algorithm for fast multiplication using Divide and Conquer algorithm
- Smallest subarray with k distinct numbers
- Longest subarray with difference exactly K between any two distinct values
- Length of longest subarray having only K distinct Prime Numbers
- Split array into maximum subarrays such that every distinct element lies in a single subarray
- Maximum length of subarray such that sum of the subarray is even
- Count of subarray that does not contain any subarray with sum 0
- First subarray having sum at least half the maximum sum of any subarray of size K
- Sum of distinct elements when elements are in range 1 to n
- Length of array pair formed where one contains all distinct elements and other all same elements
- Split an array containing N elements into K sets of distinct elements

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.