Number of ways to select equal sized subarrays from two arrays having atleast K equal pairs of elements

Given two arrays A[] and B[], and an integer K, the task is to find the number of ways to select two subarrays of same size, one from A and the other one from B such that the subarrays have at least K equal pairs of elements. (i.e. the number of pairs (A[i], B[j]) in the two selected subarrays such that A[i] = B[j] >= K).

Examples:

Input: A[] = {1, 2}, B[] = {1, 2, 3}, K = 1
Output: 4
The ways to select two subarrays are:

  1. [1], [1]
  2. [2], [2]
  3. [1, 2], [1, 2]
  4. [1, 2], [2, 3]

Input: A[] = {3, 2, 5, 21, 15, 2, 6}, B[] = {2, 1, 4, 3, 6, 7, 9}, K = 2
Output: 7

Approach:



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to count the 
// number of ways to select equal
// sized subarrays such that they
// have atleast K common elements
  
#include <bits/stdc++.h>
  
using namespace std;
  
// 2D prefix sum for submatrix 
// sum query for matrix
int prefix_2D[2005][2005];
  
// Function to find the prefix sum
// of the matrix from i and j
int subMatrixSum(int i, int j, int len)
{
    return prefix_2D[i][j] - 
           prefix_2D[i][j - len] - 
           prefix_2D[i - len][j] + 
           prefix_2D[i - len][j - len];
}
  
// Function to count the number of ways
// to select equal sized subarrays such
// that they have atleast K common elements
int numberOfWays(int a[], int b[], int n, 
                            int m, int k)
{
  
    // Combining the two arrays
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (a[i - 1] == b[j - 1])
                prefix_2D[i][j] = 1;
  
            else
                prefix_2D[i][j] = 0;
        }
    }
  
    // Calculating the 2D prefix sum
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            prefix_2D[i][j] += prefix_2D[i][j - 1];
        }
    }
  
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            prefix_2D[i][j] += prefix_2D[i - 1][j];
        }
    }
  
    int answer = 0;
  
    // iterating through all 
    // the elements of matrix
    // and considering them to 
    // be the bottom right
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
              
            // applying binary search 
            // over side length
            int low = 1;
            int high = min(i, j);
  
            while (low < high) {
                int mid = (low + high) >> 1;
  
                // if sum of this submatrix >=k then
                // new search space will be [low, mid]
                if (subMatrixSum(i, j, mid) >= k) {
                    high = mid;
                }
                // else new search space 
                // will be [mid+1, high]
                else {
                    low = mid + 1;
                }
            }
  
            // Adding the total submatrices
            if (subMatrixSum(i, j, low) >= k) {
                answer += (min(i, j) - low + 1);
            }
        }
    }
    return answer;
}
  
// Driver Code
int main()
{
    int N = 2, M = 3;
    int A[N] = { 1, 2 };
    int B[M] = { 1, 2, 3 };
  
    int K = 1;
  
    cout << numberOfWays(A, B, N, M, K);
    return 0;
}
chevron_right

Output:
4

Time Complexity: O(N * M * log(max(N, M)))





Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :