 Open in App
Not now

# C++ Program to Maximize count of corresponding same elements in given Arrays by Rotation

• Last Updated : 25 Jan, 2022

Given two arrays arr1[] and arr2[] of N integers and array arr1[] has distinct elements. The task is to find the maximum count of corresponding same elements in the given arrays by performing cyclic left or right shift on array arr1[]
Examples:

Input: arr1[] = { 6, 7, 3, 9, 5 }, arr2[] = { 7, 3, 9, 5, 6 }
Output:
Explanation:
By performing cyclic left shift on array arr1[] by 1.
Updated array arr1[] = {7, 3, 9, 5, 6}.
This rotation contains a maximum number of equal elements between array arr1[] and arr2[].
Input: arr1[] = {1, 3, 2, 4}, arr2[] = {4, 2, 3, 1}
Output:
Explanation:
By performing cyclic left shift on array arr1[] by 1.
Updated array arr1[] = {3, 2, 4, 1}
This rotation contains a maximum number of equal elements between array arr1[] and arr2[].

Approach: This problem can be solved using Greedy Approach. Below are the steps:

1. Store the position of all the elements of the array arr2[] in an array(say store[]).
2. For each element in the array arr1[], do the following:
• Find the difference(say diff) between the position of the current element in arr2[] with the position in arr1[].
• If diff is less than 0 then update diff to (N – diff).
• Store the frequency of current difference diff in a map.
3. After the above steps, the maximum frequency stored in map is the maximum number of equal elements after rotation on arr1[].

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that prints maximum ` `// equal elements ` `void` `maximumEqual(``int` `a[], ``int` `b[], ` `                  ``int` `n) ` `{ ` ` `  `    ``// Vector to store the index ` `    ``// of elements of array b ` `    ``vector<``int``> store(1e5); ` ` `  `    ``// Storing the positions of ` `    ``// array B ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``store[b[i]] = i + 1; ` `    ``} ` ` `  `    ``// frequency array to keep count ` `    ``// of elements with similar ` `    ``// difference in distances ` `    ``vector<``int``> ans(1e5); ` ` `  `    ``// Iterate through all element in arr1[] ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Calculate number of ` `        ``// shift required to ` `        ``// make current element ` `        ``// equal ` `        ``int` `d = ``abs``(store[a[i]] ` `                    ``- (i + 1)); ` ` `  `        ``// If d is less than 0 ` `        ``if` `(store[a[i]] < i + 1) { ` `            ``d = n - d; ` `        ``} ` ` `  `        ``// Store the frequency ` `        ``// of current diff ` `        ``ans[d]++; ` `    ``} ` ` `  `    ``int` `finalans = 0; ` ` `  `    ``// Compute the maximum frequency ` `    ``// stored ` `    ``for` `(``int` `i = 0; i < 1e5; i++) ` `        ``finalans = max(finalans, ` `                       ``ans[i]); ` ` `  `    ``// Printing the maximum number ` `    ``// of equal elements ` `    ``cout << finalans << " ` `"; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given two arrays ` `    ``int` `A[] = { 6, 7, 3, 9, 5 }; ` `    ``int` `B[] = { 7, 3, 9, 5, 6 }; ` ` `  `    ``int` `size = ``sizeof``(A) / ``sizeof``(A); ` ` `  `    ``// Function Call ` `    ``maximumEqual(A, B, size); ` `    ``return` `0; ` `} `

Output:

`5`

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

Please refer complete article on Maximize count of corresponding same elements in given Arrays by Rotation for more details!

My Personal Notes arrow_drop_up
Related Articles