计算放置在两个给定数组的相同索引处的相同值的元素

给定两个包含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 ² )
辅助空间： 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

      // JavaScript program for the above approach
      // Function to count maximum matched
      // elements from the arrays A[] and B[]
      function maxMatch(A, B) {
        // Stores position of elements of
        // array A[] in the array B[]
        var Aindex = {};
 
        // Keep track of difference
        // between the indices
        var diff = {};
 
        // Traverse the array A[]
        for (var i = 0; i < A.length; i++) {
          Aindex[A[i]] = i;
        }
 
        // Traverse the array B[]
        for (var i = 0; i < B.length; i++) {
          // If difference is negative, add N to it
          if (i - Aindex[B[i]] < 0) {
            if (!diff.hasOwnProperty(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.hasOwnProperty(i - Aindex[B[i]])) {
              diff[i - Aindex[B[i]]] = 1;
            }
            else {
              diff[i - Aindex[B[i]]] += 1;
            }
          }
        }
 
        // Return the max matches
        var max = 0;
        for (const [key, value] of Object.entries(diff)) {
          if (value > max) {
            max = value;
          }
        }
        return max;
      }
 
      // Driver Code
      var A = [5, 3, 7, 9, 8];
      var B = [8, 7, 3, 5, 9];
 
      // Returns the count
      // of matched elements
      document.write(maxMatch(A, B));

输出：

3

时间复杂度： O(N)
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live