Skip to content
Related Articles
Find sum of all unique elements in the array for K queries
• Last Updated : 26 May, 2021

Given an arrays arr[] in which initially all elements are 0 and another array Q[][] containing K queries where every query represents a range [L, R], the task is to add 1 to each subarrays where each subarray is defined by the the range [L, R], and return sum of all unique elements.
Note: One-based indexing is used in the Q[][] array to signify the ranges.
Examples:

Input: arr[] = { 0, 0, 0, 0, 0, 0 }, Q[] = {{1, 3}, {4, 6}, {3, 4}, {3, 3}}
Output:
Explanation:
Initially the array is arr[] = { 0, 0, 0, 0, 0, 0 }.
Query 1: arr[] = { 1, 1, 1, 0, 0, 0 }.
Query 2: arr[] = { 1, 1, 1, 1, 1, 1 }.
Query 3: arr[] = { 1, 1, 2, 2, 1, 1 }.
Query 4: arr[] = { 1, 1, 3, 2, 1, 1 }.
Hence unique elements are {1, 3, 2}. Thus sum = 1 + 3 + 2 = 6.
Input: arr[] = { 0, 0, 0, 0, 0, 0, 0, 0 }, Q[] = {{1, 4}, {5, 5}, {7, 8}, {8, 8}}
Output:
Explanation:
Initially the array is arr[] = { 0, 0, 0, 0, 0, 0, 0, 0 }.
After processing all queries, arr[] = { 1, 1, 1, 1, 1, 0, 1, 2 }.
Hence unique elements are {1, 0, 2}. Thus sum = 1 + 0 + 2 = 3.

Approach: The idea is to increment the value by 1 and decrement the array by 1 at L and R+1 index respectively for processing each query. Then, Compute the prefix sum of the array to find the final array after Q queries. As explained in this article. Finally, compute the sum of the unique elements with the help of the hash-map.
Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// sum of all unique elements of``// the array after Q queries` `#include ` `using` `namespace` `std;`  `// Function to find the sum of``// unique elements after Q Query``int` `uniqueSum(``int` `A[], ``int` `R[],``            ``int` `N, ``int` `M)``{``    ``// Updating the array after``    ``// processing each query``    ``for` `(``int` `i = 0; i < M; ++i) {` `        ``int` `l = R[i], r = R[i] + 1;` `        ``// Making it to 0-indexing``        ``l--;``        ``r--;``        ``A[l]++;` `        ``if` `(r < N)``            ``A[r]--;``    ``}` `    ``// Iterating over the array``    ``// to get the final array``    ``for` `(``int` `i = 1; i < N; ++i) {``        ``A[i] += A[i - 1];``    ``}` `    ``// Variable to store the sum``    ``int` `ans = 0;` `    ``// Hash to maintain perviously``    ``// occured elements``    ``unordered_set<``int``> s;` `    ``// Loop to find the maximum sum``    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``if` `(s.find(A[i]) == s.end())``            ``ans += A[i];` `        ``s.insert(A[i]);``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `A[] = { 0, 0, 0, 0, 0, 0 };``    ``int` `R[]``        ``= { { 1, 3 }, { 4, 6 },``            ``{ 3, 4 }, { 3, 3 } };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A);``    ``int` `M = ``sizeof``(R) / ``sizeof``(R);` `    ``cout << uniqueSum(A, R, N, M);` `    ``return` `0;``}`

## Java

 `// Java implementation to find the``// sum of all unique elements of``// the array after Q queries` `import` `java.util.*;` `class` `GFG{` `// Function to find the sum of``// unique elements after Q Query``static` `int` `uniqueSum(``int` `A[], ``int` `R[][],``                     ``int` `N, ``int` `M)``{``    ``// Updating the array after``    ``// processing each query``    ``for` `(``int` `i = ``0``; i < M; ++i)``    ``{``        ``int` `l = R[i][``0``], r = R[i][``1``] + ``1``;` `        ``// Making it to 0-indexing``        ``l--;``        ``r--;``        ``A[l]++;``        ` `        ``if` `(r < N)``            ``A[r]--;``    ``}` `    ``// Iterating over the array``    ``// to get the final array``    ``for` `(``int` `i = ``1``; i < N; ++i)``    ``{``        ``A[i] += A[i - ``1``];``    ``}` `    ``// Variable to store the sum``    ``int` `ans = ``0``;` `    ``// Hash to maintain perviously``    ``// occured elements``    ``HashSet s = ``new` `HashSet();` `    ``// Loop to find the maximum sum``    ``for` `(``int` `i = ``0``; i < N; ++i)``    ``{``        ``if` `(!s.contains(A[i]))``            ``ans += A[i];` `        ``s.add(A[i]);``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `};``    ``int` `R[][] = { { ``1``, ``3` `}, { ``4``, ``6` `},``                  ``{ ``3``, ``4` `}, { ``3``, ``3` `} };``    ``int` `N = A.length;``    ``int` `M = R.length;``    ``System.out.print(uniqueSum(A, R, N, M));``}``}` `// This code is contributed by gauravrajput1`

## Python 3

 `# Python implementation to find the``# sum of all unique elements of``# the array after Q queries` `# Function to find the sum of``# unique elements after Q Query``def` `uniqueSum(A, R, N, M) :` `    ``# Updating the array after``    ``# processing each query``    ``for` `i ``in` `range``(``0``, M) :` `        ``l ``=` `R[i][``0``]``        ``r ``=` `R[i][``1``] ``+` `1` `        ``# Making it to 0-indexing``        ``l ``-``=` `1``        ``r ``-``=` `1``        ``A[l] ``+``=` `1` `        ``if` `(r < N) :``            ``A[r] ``-``=` `1` `    ``# Iterating over the array``    ``# to get the final array``    ``for` `i ``in` `range``(``1``, N) :``        ``A[i] ``+``=` `A[i ``-` `1``]` `    ``# Variable to store the sum``    ``ans ``=` `0` `    ``# Hash to maintain perviously``    ``# occured elements``    ``s ``=` `{``chr``}` `    ``# Loop to find the maximum sum``    ``for` `i ``in` `range``(``0``, N) :``        ``if` `(A[i] ``not` `in` `s) :``            ``ans ``+``=` `A[i]` `        ``s.add(A[i])` `    ``return` `ans` `# Driver code``A ``=` `[ ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `]``R ``=` `[ [ ``1``, ``3` `], [ ``4``, ``6` `],``      ``[ ``3``, ``4` `], [ ``3``, ``3` `] ]``N ``=` `len``(A)``M ``=` `len``(R)` `print``(uniqueSum(A, R, N, M))` `# This code is contributed by Sanjit_Prasad`

## C#

 `// C# implementation to find the``// sum of all unique elements of``// the array after Q queries``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the sum of``// unique elements after Q Query``static` `int` `uniqueSum(``int` `[]A, ``int` `[,]R,``                     ``int` `N, ``int` `M)``{``    ` `    ``// Updating the array after``    ``// processing each query``    ``for``(``int` `i = 0; i < M; ++i)``    ``{``       ``int` `l = R[i, 0], r = R[i, 1] + 1;``       ` `       ``// Making it to 0-indexing``       ``l--;``       ``r--;``       ``A[l]++;``       ` `       ``if` `(r < N)``           ``A[r]--;``    ``}` `    ``// Iterating over the array``    ``// to get the readonly array``    ``for``(``int` `i = 1; i < N; ++i)``    ``{``       ``A[i] += A[i - 1];``    ``}` `    ``// Variable to store the sum``    ``int` `ans = 0;` `    ``// Hash to maintain perviously``    ``// occured elements``    ``HashSet<``int``> s = ``new` `HashSet<``int``>();` `    ``// Loop to find the maximum sum``    ``for``(``int` `i = 0; i < N; ++i)``    ``{``       ``if` `(!s.Contains(A[i]))``           ``ans += A[i];``       ``s.Add(A[i]);``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 0, 0, 0, 0, 0, 0 };``    ``int` `[,]R = { { 1, 3 }, { 4, 6 },``                 ``{ 3, 4 }, { 3, 3 } };``                 ` `    ``int` `N = A.Length;``    ``int` `M = R.GetLength(0);``    ` `    ``Console.Write(uniqueSum(A, R, N, M));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
`6`

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up