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

📅  最后修改于: 2021-09-03 03:18:17             🧑  作者: Mango

给定两个包含N 个唯一元素的数组A[]B[] ,任务是从两个给定数组中找到匹配元素的最大数量。

例子:

朴素的方法:解决这个问题的最简单的方法是观察一次右移(N-1) 次左移相同,因此只执行一种类型的移位,比如右移。此外,对A执行右移与执行左移B相同因此仅对一个数组执行右移,例如在A[] 上。对A应用右移操作,同时保持B不变,并比较AB 的所有值以找到匹配的总数并跟踪所有匹配项中的最大值。

时间复杂度: 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)

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