给定两个包含N 个唯一元素的数组A[]和B[] ，任务是从两个给定数组中找到匹配元素的最大数量。
Elements of 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 modifies B[] to { 7, 3, 5, 9, 8 }.
Therefore, elements in 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[] 上。对A应用右移操作，同时保持B不变，并比较A和B 的所有值以找到匹配的总数并跟踪所有匹配项中的最大值。
时间复杂度： O(N 2 )
辅助空间： O(1)
有效的方法：可以通过使用 Map 跟踪数组A[]和B[] 中存在的相等元素的索引之间的差异来优化上述方法。如果差值为负，则通过执行k( = N + difference)左移来更改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 Javascript
输出：
3时间复杂度： O(N)
辅助空间： O(N)
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。