给定N个唯一元素的两个数组A []和B [] ，任务是从两个给定数组中找到匹配元素的最大数量。
Elements from the two arrays are matched if they are of the same value and can be placed at the same index (0-based indexing).(By right shift or left shift of the two arrays).
例子：
Input: A[] = { 5, 3, 7, 9, 8 }, B[] = { 8, 7, 3, 5, 9 }
Output: 3
Explanation: Left shifting B[] by 1 index modifes B[] to { 7, 3, 5, 9, 8 }.
Therefore, elements at indices 1, 3 and 4 match. Therefore, the required count is 3.
Input: A[] = { 9, 5, 6, 2 }, B[] = { 6, 2, 9, 5 }
Output: 4
天真的方法：解决此问题的最简单方法是观察到一个右移与(N-1)个左移相同，因此仅执行一种类型的移，即右移。在A上执行右移的操作与在B上执行左移的操作相同，因此仅对一个数组(例如A [])执行右移。在保持B不变的情况下对A进行右移运算，并比较A和B的所有值以找到匹配的总数并跟踪所有的最大值。
时间复杂度： O(N 2 )
辅助空间： O(1)
高效的方法：可以通过使用Map来跟踪数组A []和B []中存在的相等元素的索引之间的差异，从而优化上述方法。如果差异为负，则通过进行k(= N +差异)左移来更改A [] ，这等效于N – K右移。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to count maximum matched
// elements from the arrays A[] and B[]
int maxMatch(int A[], int B[], int M, int N)
{
// Stores position of elements of
// array A[] in the array B[]
map Aindex;
// Keep track of difference
// between the indices
map diff;
// Traverse the array A[]
for(int i = 0; i < M; i++)
{
Aindex[A[i]] = i ;
}
// Traverse the array B[]
for(int i = 0; i < N; i++)
{
// If difference is negative, add N to it
if (i - Aindex[B[i]] < 0)
{
diff[M + i - Aindex[B[i]]] += 1;
}
// Keep track of the number of shifts
// required to place elements at same indices
else
{
diff[i - Aindex[B[i]]] += 1;
}
}
// Return the max matches
int max = 0;
for(auto ele = diff.begin(); ele != diff.end(); ele++)
{
if(ele->second > max)
{
max = ele->second;
}
}
return max;
}
// Driver code
int main()
{
int A[] = { 5, 3, 7, 9, 8 };
int B[] = { 8, 7, 3, 5, 9 };
int M = sizeof(A) / sizeof(A[0]);
int N = sizeof(B) / sizeof(B[0]);
// Returns the count
// of matched elements
cout << maxMatch(A, B, M, N);
return 0;
}
// This code is contributed by divyeshrabadiya07 Java
// Java program for the above approach
import java.io.Console;
import java.util.HashMap;
import java.util.Map;
class GFG
{
// Function to count maximum matched
// elements from the arrays A[] and B[]
static int maxMatch(int[] A, int[] B)
{
// Stores position of elements of
// array A[] in the array B[]
HashMap Aindex = new HashMap();
// Keep track of difference
// between the indices
HashMap diff = new HashMap();
// Traverse the array A[]
for (int i = 0; i < A.length; i++)
{
Aindex.put(A[i], i);
}
// Traverse the array B[]
for (int i = 0; i < B.length; i++)
{
// If difference is negative, add N to it
if (i - Aindex.get(B[i]) < 0)
{
if (!diff.containsKey(A.length + i - Aindex.get(B[i])))
{
diff.put(A.length + i - Aindex.get(B[i]), 1);
} else {
diff.put(A.length + i - Aindex.get(B[i]), diff.get(A.length + i - Aindex.get(B[i])) + 1);
}
}
// Keep track of the number of shifts
// required to place elements at same indices
else {
if (!diff.containsKey(i - Aindex.get(B[i]))) {
diff.put(i - Aindex.get(B[i]), 1);
}
else
{
diff.put(i - Aindex.get(B[i]),
diff.get(i - Aindex.get(B[i])) + 1);
}
}
}
// Return the max matches
int max = 0;
for (Map.Entry ele : diff.entrySet())
{
if (ele.getValue() > max)
{
max = ele.getValue();
}
}
return max;
}
// Driver Code
public static void main(String[] args)
{
int[] A = { 5, 3, 7, 9, 8 };
int[] B = { 8, 7, 3, 5, 9 };
// Returns the count
// of matched elements
System.out.println(maxMatch(A, B));
}
}
// This code is contributed by 29AjayKumar Python3
# Python program for the above approach
# Function to count maximum matched
# elements from the arrays A[] and B[]
def maxMatch(A, B):
# Stores position of elements of
# array A[] in the array B[]
Aindex = {}
# Keep track of difference
# between the indices
diff = {}
# Traverse the array A[]
for i in range(len(A)):
Aindex[A[i]] = i
# Traverse the array B[]
for i in range(len(B)):
# If difference is negative, add N to it
if i-Aindex[B[i]] < 0:
if len(A)+i-Aindex[B[i]] not in diff:
diff[len(A)+i-Aindex[B[i]]] = 1
else:
diff[len(A)+i-Aindex[B[i]]] += 1
# Keep track of the number of shifts
# required to place elements at same indices
else:
if i-Aindex[B[i]] not in diff:
diff[i-Aindex[B[i]]] = 1
else:
diff[i-Aindex[B[i]]] += 1
# Return the max matches
return max(diff.values())
# Driver Code
A = [5, 3, 7, 9, 8]
B = [8, 7, 3, 5, 9]
# Returns the count
# of matched elements
print(maxMatch(A, B))C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to count maximum matched
// elements from the arrays A[] and B[]
static int maxMatch(int[] A, int[] B)
{
// Stores position of elements of
// array A[] in the array B[]
Dictionary Aindex = new Dictionary();
// Keep track of difference
// between the indices
Dictionary diff = new Dictionary();
// Traverse the array A[]
for(int i = 0; i < A.Length; i++)
{
Aindex[A[i]] = i ;
}
// Traverse the array B[]
for(int i = 0; i < B.Length; i++)
{
// If difference is negative, add N to it
if (i - Aindex[B[i]] < 0)
{
if (!diff.ContainsKey(A.Length + i -
Aindex[B[i]]))
{
diff[A.Length + i - Aindex[B[i]]] = 1;
}
else
{
diff[A.Length + i - Aindex[B[i]]] += 1;
}
}
// Keep track of the number of shifts
// required to place elements at same indices
else
{
if (!diff.ContainsKey(i - Aindex[B[i]]))
{
diff[i - Aindex[B[i]]] = 1;
}
else
{
diff[i - Aindex[B[i]]] += 1;
}
}
}
// Return the max matches
int max = 0;
foreach(KeyValuePair ele in diff)
{
if (ele.Value > max)
{
max = ele.Value;
}
}
return max;
}
// Driver Code
static void Main()
{
int[] A = { 5, 3, 7, 9, 8 };
int[] B = { 8, 7, 3, 5, 9 };
// Returns the count
// of matched elements
Console.WriteLine(maxMatch(A, B));
}
}
// This code is contributed by divyesh072019 输出：
3时间复杂度： O(N)
辅助空间： O(N)