Given an array **arr[]** consisting of **N** integers, read every element of the array one by one and perform the following operations:

- If the current element
**arr[i]**had previously occurred in the array, increase its first occurrence by**K**. - Otherwise, insert
**arr[i]**into the sequence

The task is to print the final sequence of integers obtained by performing the above operations

**Examples:**

Input:arr[] = {1, 2, 3, 2, 3}, K = 1Output:[1, 4, 3, 2, 3]Explanation:Arrival : 1

Since 1 is the first element in the stream, simply insert it into the solution.

Therefore, b[] = [1]Arrival: 2

Since 2 is not existing in the array, simply insert it into the solution.

Therefore, b[] = [1, 2]Arrival: 3

Since 3 is not existing in the array, simply insert it into the solution.

Therefore, b[] = [1, 2, 3]Arrival: 2

Since 2 already exists, increasing its first occurrence by K(=1)modifies the array b[] to [1, 3, 3, 2]Arrival: 3

Since 3 already exists, increasing its first occurrence by K(=1)modifies the array b[] to [1, 4, 3, 2, 3]

Input:arr[] = {1, 4, 1, 1, 4}, K = 6Output: [7, 10, 7, 1, 4]

**Naive Approach:** The simplest approach to solve the problem is to traverse the array, and for every array element **arr[i]**, traverse in the range **[0, i – 1]** to check if **arr[i]** is already present in the array or not. If found to be true, increase the first occurrence of **arr[i] **by **K**.**Time Complexity:** O(N^{2})**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can be optimized using **Hashing**. Follow the steps below to solve the problem:

- Traverse the array and store the occurrence of every array element in a Map paired with the index of its occurrence in increasing order.
- If
**arr[i]**is found to be already present in the**Map**, remove the first occurrence of**arr[i**] from the**Map**. Insert that index paired with**arr[i] + K**as the key back into the**Map**. - Repeat the above steps for all array elements. Once, the entire array is traversed, obtain the sequence of integers from the
**Map**and print the final sequence.

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Print the required final sequence` `void` `printSequence(vector<` `int` `>& A,` ` ` `int` `n, ` `int` `k)` `{` ` ` `// Stores the array element-index pairs` ` ` `unordered_map<` `int` `, set<` `int` `> > mp;` ` ` ` ` `// Stores the required sequence` ` ` `vector<` `int` `> sol;` ` ` ` ` `// Insert all array elements` ` ` `for` `(` `int` `x : A)` ` ` `sol.push_back(x);` ` ` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// If current element has` ` ` `// not occurred previously` ` ` `if` `(mp.find(sol[i]) == mp.end()` ` ` `|| mp[sol[i]].size() == 0) {` ` ` `mp[sol[i]].insert(i);` ` ` `}` ` ` ` ` `// Otherwise` ` ` `else` `{` ` ` ` ` `// Iterator to the first index` ` ` `// containing sol[i]` ` ` `auto` `idxx = mp[sol[i]].begin();` ` ` ` ` `int` `idx = *idxx;` ` ` ` ` `// Remove that occurrence` ` ` `mp[sol[i]].erase(idxx);` ` ` ` ` `// Increment by K` ` ` `sol[idx] += k;` ` ` ` ` `// Insert the incremented` ` ` `// element at that index` ` ` `mp[sol[idx]].insert(idx);` ` ` `mp[sol[i]].insert(i);` ` ` `}` ` ` `}` ` ` ` ` `// Print the final sequence` ` ` `for` `(` `int` `x : sol) {` ` ` `cout << x << ` `" "` `;` ` ` `}` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 5;` ` ` `int` `K = 6;` ` ` `vector<` `int` `> A = { 1, 4, 1, 1, 4 };` ` ` `printSequence(A, N, K);` `}` |

**Output:**

7 10 7 1 4

**Time Complexity:** O(NlogN)**Auxiliary Space:** O(N)

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.