# Array sum after replacing all occurrences of X by Y for Q queries

• Last Updated : 27 May, 2021

Given an integer array arr[] and Q queries, the task is to find the sum of the array for each query of the following type:

• Each query contains 2 integers X and Y, where all the occurrences of X in arr[] are to be replaced by Y.
• After each query, they print the sum of the array.

Examples:

Input: arr[] = { 1, 2, 1, 3, 2}, X[] = { 2, 3, 5 }, Y[] = { 3, 1, 2 }
Output: 11 5 5
Explanation:
After the 1st query, replace 2 with 3, arr[] = { 1, 3, 1, 3, 3 }, Sum = 11.
After the 2nd query, replace 3 with 1, arr[] = { 1, 1, 1, 1, 1 }, Sum = 5.
After the 3rd query, replace 5 with 2, arr[] = { 1, 1, 1, 1, 1 }, Sum = 5.

Input: arr[] = { 12, 22, 11, 11, 2}, X[] = {2, 11, 22}, Y[] = {12, 222, 2}
Output: 68 490 470

Naive Approach:
The simplest approach to solve the problem mentioned above is to traverse through the array and replace all the instances of X with Y for each query and calculate the sum.

Time Complexity: O(N * Q)

Efficient Approach:
To optimize the above method, follow the steps given below:

• Precompute and store the sum of the array in a variable S and store the frequencies of array elements in a Map count.
• Then, do the following for each query:
• Find the frequency of X stored on the map.
• Subtract X * count[X] from S.
• Set count[Y] = count[X] and then count[X] = 0.
• Add Y * count[Y] to S.
• Print the updated value of S.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the sum``// of the array for the given Q queries` `#include ``using` `namespace` `std;` `// Function that print the sum of``// the array for Q queries``void` `sumOfTheArrayForQuery(``int``* A, ``int` `N,``                           ``int``* X, ``int``* Y,``                           ``int` `Q)``{``    ``int` `sum = 0;` `    ``// Stores the frequencies``    ``// of array elements``    ``unordered_map<``int``, ``int``> count;` `    ``// Calculate the sum of``    ``// the initial array and``    ``// store the frequency of``    ``// each element in map` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``sum += A[i];``        ``count[A[i]]++;``    ``}` `    ``// Iterate for all the queries` `    ``for` `(``int` `i = 0; i < Q; i++) {``        ``// Store query values``        ``int` `x = X[i], y = Y[i];` `        ``// Decrement the sum accordingly``        ``sum -= count[X[i]] * X[i];` `        ``// Increment the sum accordingly``        ``sum += count[X[i]] * Y[i];` `        ``// Set count of Y[i]``        ``count[Y[i]] += count[X[i]];` `        ``// Reset count of X[i]``        ``count[X[i]] = 0;` `        ``// Print the sum``        ``cout << sum << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 1, 3, 2 };``    ``int` `X[] = { 2, 3, 5 };``    ``int` `Y[] = { 3, 1, 2 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `Q = ``sizeof``(X) / ``sizeof``(X);` `    ``// Function call``    ``sumOfTheArrayForQuery(arr, N, X, Y, Q);` `    ``return` `0;``}`

## Java

 `// Java implementation to``// find the sum of the array``// for the given Q queries``import` `java.util.*;``class` `GFG{``  ` `// Function that print the sum of``// the array for Q queries``public` `static` `void` `sumOfTheArrayForQuery(``int``[] A, ``int` `N,``                                         ``int``[] X, ``int``[] Y,``                                         ``int` `Q)``{``  ``int` `sum = ``0``;` `  ``// Stores the frequencies``  ``// of array elements``  ``// Create an empty hash map``  ``HashMap count = ``new` `HashMap<>();` `  ``// Calculate the sum of``  ``// the initial array and``  ``// store the frequency of``  ``// each element in map``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``sum += A[i];``    ``if` `(count.containsKey(A[i]))``    ``{``      ``count.replace(A[i],``      ``count.get(A[i]) + ``1``);``    ``}``    ``else``    ``{``      ``count.put(A[i], ``1``);``    ``}``  ``}` `  ``// Iterate for all the queries``  ``for` `(``int` `i = ``0``; i < Q; i++)``  ``{``    ``// Store query values``    ``int` `x = X[i], y = Y[i];` `    ``if``(count.containsKey(X[i]))``    ``{``      ``// Decrement the sum accordingly``      ``sum -= count.get(X[i]) * X[i];``      ``// Increment the sum accordingly``      ``sum += count.get(X[i]) * Y[i];``    ``}` `    ``// Set count of Y[i]``    ``if``(count.containsKey(Y[i]) &&``       ``count.containsKey(X[i]))``    ``{``      ``count.replace(Y[i],``      ``count.get(Y[i]) +``      ``count.get(X[i]));``    ``}` `    ``// Reset count of X[i]``    ``if``(count.containsKey(X[i]))``    ``{``      ``count.replace(X[i], ``0``);``    ``}` `    ``// Print the sum``    ``System.out.print(sum + ``" "``);``  ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``int` `arr[] = {``1``, ``2``, ``1``, ``3``, ``2``};``  ``int` `X[] = {``2``, ``3``, ``5``};``  ``int` `Y[] = {``3``, ``1``, ``2``};` `  ``int` `N = arr.length;``  ``int` `Q = X.length;` `  ``// Function call``  ``sumOfTheArrayForQuery(arr, N,``                        ``X, Y, Q);``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 implementation to find the sum``# of the array for the given Q queries` `# Function that print the sum of``# the array for Q queries``def` `sumOfTheArrayForQuery(A, N, X, Y, Q):``    ` `    ``sum` `=` `0` `    ``# Stores the frequencies``    ``# of array elements``    ``count ``=` `{}` `    ``# Calculate the sum of``    ``# the initial array and``    ``# store the frequency of``    ``# each element in map``    ``for` `i ``in` `range``(N):``        ``sum` `+``=` `A[i]``        ` `        ``if` `A[i] ``in` `count:``            ``count[A[i]] ``+``=` `1``        ``else``:``            ``count[A[i]] ``=` `1` `    ``# Iterate for all the queries``    ``for` `i ``in` `range``(Q):` `        ``# Store query values``        ``x ``=` `X[i]``        ``y ``=` `Y[i]``        ` `        ``if` `X[i] ``not` `in` `count:``            ``count[X[i]] ``=` `0``        ``if` `Y[i] ``not` `in` `count:``            ``count[Y[i]] ``=` `0` `        ``# Decrement the sum accordingly``        ``sum` `-``=` `(count[X[i]] ``*` `X[i])` `        ``# Increment the sum accordingly``        ``sum` `+``=` `count[X[i]] ``*` `Y[i]` `        ``# Set count of Y[i]``        ``count[Y[i]] ``+``=` `count[X[i]]` `        ``# Reset count of X[i]``        ``count[X[i]] ``=` `0` `        ``# Print the sum``        ``print``(``sum``, end ``=` `" "``)` `# Driver Code``arr ``=` `[ ``1``, ``2``, ``1``, ``3``, ``2``, ]``X ``=` `[ ``2``, ``3``, ``5` `]``Y ``=` `[ ``3``, ``1``, ``2` `]``N ``=` `len``(arr)``Q ``=` `len``(X)` `# Function call``sumOfTheArrayForQuery(arr, N, X, Y, Q)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# implementation to``// find the sum of the array``// for the given Q queries``using` `System;``using` `System.Collections.Generic;``class` `GFG{``  ` `// Function that print the sum of``// the array for Q queries``public` `static` `void` `sumOfTheArrayForQuery(``int``[] A, ``int` `N,``                                         ``int``[] X, ``int``[] Y,``                                         ``int` `Q)``{``  ``int` `sum = 0;` `  ``// Stores the frequencies``  ``// of array elements``  ``// Create an empty hash map``  ``Dictionary<``int``,``             ``int``> count = ``new` `Dictionary<``int``,``                                         ``int``>();` `  ``// Calculate the sum of``  ``// the initial array and``  ``// store the frequency of``  ``// each element in map``  ``for` `(``int` `i = 0; i < N; i++)``  ``{``    ``sum += A[i];``    ``if` `(count.ContainsKey(A[i]))``    ``{``      ``count[A[i]]= count[A[i]] + 1;``    ``}``    ``else``    ``{``      ``count.Add(A[i], 1);``    ``}``  ``}` `  ``// Iterate for all the queries``  ``for` `(``int` `i = 0; i < Q; i++)``  ``{``    ``// Store query values``    ``int` `x = X[i], y = Y[i];` `    ``if``(count.ContainsKey(X[i]))``    ``{``      ``// Decrement the sum accordingly``      ``sum -= count[X[i]] * X[i];``      ``// Increment the sum accordingly``      ``sum += count[X[i]] * Y[i];``    ``}` `    ``// Set count of Y[i]``    ``if``(count.ContainsKey(Y[i]) &&``       ``count.ContainsKey(X[i]))``    ``{``      ``count[Y[i]] = count[Y[i]] +``                    ``count[X[i]];``    ``}` `    ``// Reset count of X[i]``    ``if``(count.ContainsKey(X[i]))``    ``{``      ``count[X[i]] = 0;``    ``}` `    ``// Print the sum``    ``Console.Write(sum + ``" "``);``  ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``int` `[]arr = {1, 2, 1, 3, 2};``  ``int` `[]X = {2, 3, 5};``  ``int` `[]Y = {3, 1, 2};` `  ``int` `N = arr.Length;``  ``int` `Q = X.Length;` `  ``// Function call``  ``sumOfTheArrayForQuery(arr, N,``                        ``X, Y, Q);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`11 5 5`

Time Complexity: O(N), as each query has a computational complexity of O(1).
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up