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 queriesvoid sumOfTheArrayForQuery(int* A, int N,                           int* X, int* Y,                           int Q){    int sum = 0;     // Stores the frequencies    // of array elements    unordered_map 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 Codeint 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 queriesimport java.util.*;class GFG{   // Function that print the sum of// the array for Q queriespublic 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 codepublic 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 queriesdef 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 Codearr = [ 1, 2, 1, 3, 2, ]X = [ 2, 3, 5 ]Y = [ 3, 1, 2 ]N = len(arr)Q = len(X) # Function callsumOfTheArrayForQuery(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 queriesusing System;using System.Collections.Generic;class GFG{   // Function that print the sum of// the array for Q queriespublic 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 count = new Dictionary();   // 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 codepublic 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