Java Program to Maximize count of corresponding same elements in given permutations using cyclic rotations

Given two permutations P1 and P2 of numbers from 1 to N, the task is to find the maximum count of corresponding same elements in the given permutations by performing a cyclic left or right shift on P1. 
Examples: 

Input: P1 = [5 4 3 2 1], P2 = [1 2 3 4 5] 
Output: 1 
Explanation: 
We have a matching pair at index 2 for element 3.
Input: P1 = [1 3 5 2 4 6], P2 = [1 5 2 4 3 6] 
Output: 3 
Explanation: 
Cyclic shift of second permutation towards right would give 6 1 5 2 4 3, and we get a match of 5, 2, 4. Hence, the answer is 3 matching pairs. 
 

Naive Approach: The naive approach is to check for every possible shift in both the left and right direction count the number of matching pairs by looping through all the permutations formed. 
Time Complexity: O(N²) 
Auxiliary Space: O(1)
Efficient Approach: The above naive approach can be optimized. The idea is for every element to store the smaller distance between positions of this element from the left and right sides in separate arrays. Hence, the solution to the problem will be calculated as the maximum frequency of an element from the two separated arrays. Below are the steps:  

1. Store the position of all the elements of the permutation P2 in an array(say store[]).
2. For each element in the permutation P1, do the following: 
   
   • Find the difference(say diff) between the position of the current element in P2 with the position in P1.
   • 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 the map is the maximum number of equal elements after rotation on P1.

Below is the implementation of the above approach:
 

1

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