Given two arrays **A** and **B** of the same length **N**, filled with a permutation of natural numbers from **1** to **N**, the task is to count the number of common subarrays in **A** and **B**.

**Examples:**

Input:A = [1, 2, 3], B = [2, 3, 1]

Output:4

Explanation:

The common subarrays are [1], [2], [3], [2, 3]

Hence, total count = 4

Input:A = [1, 2, 3, 4, 5], B = [2, 3, 1, 4, 5]

Output:7

Explanation:

The common subarrays are [1], [2], [3], [4], [5], [2, 3], [4, 5]

Hence, total count = 7

**Naive Approach:**

The idea is to generate all subarrays of **A** and **B** separately, which would take **O(N ^{2})** for each array. Now, compare all subarrays of A with all subarrays of B and count common subarrays. It would take

**O(N**.

^{4})**Efficient Approach:**

The idea is to use Hashing to solve this problem efficiently.

- Create a Hash array
**H**of size**N+1**. - Represent all elements of
**A**by their respective indices:**Element****Representaion**A[0] 0 A[1] 1 A[2] 2 . . and so on. - Use array H to store this representation,
**H[ A[ i ] ] = i** - Update the elements of
**B**according to this new representation using H,**B[ i ] = H[ B[ i ] ]** - Now, array A can be represented as [0, 1, 2, ..N], so simply count number of subarrays in B which have consecutive elements. Once we get length
**K**of subarray of consecutive elements, count total possible subarray using following relation:

**Total number of subarrays**= (**K*** (**K**+**1**)) /**2**

Look at this example to understand this approach in detail:

Example:

A = [4, 3, 1, 2, 5]

B = [3, 1, 2, 4, 5]

Common subarrays are [1], [2], [3], [4], [5], [3, 1], [1, 2], [3, 1, 2] = 8

1.Represent A[i] as i, and store in H as H[A[i]] = i, Now array H from index 1 to N is,

H = [2, 3, 1, 0, 4]

2.Update B according to H, B[i] = H[B[i]]

B = [1, 2, 3, 0, 4]

3.Look for subarray in B with consecutive elements,

Subarray from index 0 to 2 is [1, 2, 3], consisting of consecutive elements with length K = 3

Element at index 3 forms a subarray [0] of length K = 1

Element at index 4 forms a subarray [4] of length K = 1

4.Total number of common subarrays =

(3*(3+1))/2 + (1*(1+1))/2 + (1*(1+1))/2 = 6 + 1 + 1 = 8

Below is the implementation of the above approach:

## C++

`// C++ implementation of above approach ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `int` `commonSubarrays(` `int` `*A, ` `int` `*B, ` `int` `N) ` `{ ` ` ` `// Initialising Map for ` ` ` `// Index Mapping ` ` ` `int` `Map[N + 1]; ` ` ` ` ` `// Mapping elements of A ` ` ` `for` `(` `int` `i = 0 ; i< N; i++) ` ` ` `Map[*(A + i)] = i; ` ` ` ` ` `// Modify elements of B ` ` ` `// according to Map ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `{ ` ` ` `// Changing B[i] as ` ` ` `// the index of B[i] in A ` ` ` `*(B + i) = Map[*(B + i)]; ` ` ` `} ` ` ` ` ` `// Count of common subarrays ` ` ` `int` `count = 0; ` ` ` ` ` `// Traversing array B ` ` ` `int` `i = 0, K; ` ` ` `while` `(i < N) ` ` ` `{ ` ` ` `K = 1; ` ` ` `i+= 1; ` ` ` ` ` `// While consecutive elements ` ` ` `// are found, we increment K ` ` ` `while` `(i < N && B[i] == B[i - 1] + 1) ` ` ` `{ ` ` ` `i += 1; ` ` ` `K += 1; ` ` ` `} ` ` ` ` ` `// Add number of subarrays ` ` ` `//with length K ` ` ` `// to total count ` ` ` `count = count + ((K) * (K + 1)) / 2; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `N = 3; ` ` ` `int` `A[] = {1, 2, 3}; ` ` ` `int` `B[] = {2, 3, 1}; ` ` ` `cout << (commonSubarrays(A, B, N)) ` ` ` `<< endl; ` ` ` ` ` `N = 5; ` ` ` `int` `C[] = {1, 2, 3, 4, 5}; ` ` ` `int` `D[] = {2, 3, 1, 4, 5}; ` ` ` `cout << (commonSubarrays(C, D, N)); ` `} ` ` ` `// This code is contributed by chitranayal ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the above approach ` `class` `GFG{ ` ` ` `static` `int` `commonSubarrays(` `int` `[]A, ` ` ` `int` `[]B, ` `int` `N) ` `{ ` ` ` ` ` `// Initialising Map for ` ` ` `// Index Mapping ` ` ` `int` `[]Map = ` `new` `int` `[N + ` `1` `]; ` ` ` ` ` `// Mapping elements of A ` ` ` `for` `(` `int` `i = ` `0` `; i< N; i++) ` ` ` `Map[A[i]] = i; ` ` ` ` ` `// Modify elements of B ` ` ` `// according to Map ` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) ` ` ` `{ ` ` ` ` ` `// Changing B[i] as ` ` ` `// the index of B[i] in A ` ` ` `B[i] = Map[B[i]]; ` ` ` `} ` ` ` ` ` `// Count of common subarrays ` ` ` `int` `count = ` `0` `; ` ` ` ` ` `// Traversing array B ` ` ` `int` `i = ` `0` `, K; ` ` ` `while` `(i < N) ` ` ` `{ ` ` ` `K = ` `1` `; ` ` ` `i+= ` `1` `; ` ` ` ` ` `// While consecutive elements ` ` ` `// are found, we increment K ` ` ` `while` `(i < N && B[i] == B[i - ` `1` `] + ` `1` `) ` ` ` `{ ` ` ` `i += ` `1` `; ` ` ` `K += ` `1` `; ` ` ` `} ` ` ` ` ` `// Add number of subarrays ` ` ` `//with length K ` ` ` `// to total count ` ` ` `count = count + ((K) * (K + ` `1` `)) / ` `2` `; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `N = ` `3` `; ` ` ` `int` `A[] = {` `1` `, ` `2` `, ` `3` `}; ` ` ` `int` `B[] = {` `2` `, ` `3` `, ` `1` `}; ` ` ` `System.out.print(commonSubarrays(A, B, N)); ` ` ` `System.out.print(` `"\n"` `); ` ` ` ` ` `N = ` `5` `; ` ` ` `int` `C[] = {` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `}; ` ` ` `int` `D[] = {` `2` `, ` `3` `, ` `1` `, ` `4` `, ` `5` `}; ` ` ` `System.out.print(commonSubarrays(C, D, N)); ` `} ` `} ` ` ` `// This code is contributed by gauravrajput1 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of above approach ` ` ` `def` `commonSubarrays(A, B, N): ` ` ` ` ` `# Initialising Map for ` ` ` `# Index Mapping ` ` ` `Map` `=` `[` `0` `for` `i ` `in` `range` `(N ` `+` `1` `)] ` ` ` ` ` `# Mapping elements of A ` ` ` `for` `i ` `in` `range` `(N): ` ` ` `Map` `[A[i]]` `=` `i ` ` ` ` ` `# Modify elements of B ` ` ` `# according to Map ` ` ` `for` `i ` `in` `range` `(N) : ` ` ` ` ` `# Changing B[i] as ` ` ` `# the index of B[i] in A ` ` ` `B[i]` `=` `Map` `[B[i]] ` ` ` ` ` `# Count of common subarrays ` ` ` `count ` `=` `0` ` ` ` ` `# Traversing array B ` ` ` `i ` `=` `0` ` ` `while` `i<N: ` ` ` `K ` `=` `1` ` ` `i` `+` `=` `1` ` ` ` ` `# While consecutive elements ` ` ` `# are found, we increment K ` ` ` `while` `i<N ` `and` `B[i]` `=` `=` `B[i` `-` `1` `]` `+` `1` `: ` ` ` `i` `+` `=` `1` ` ` `K` `+` `=` `1` ` ` ` ` `# Add number of subarrays ` ` ` `# with length K ` ` ` `# to total count ` ` ` `count ` `=` `count ` `+` `( ` ` ` `(K)` `*` `(K ` `+` `1` `))` `/` `/` `2` ` ` ` ` `return` `count ` ` ` `# Driver code ` `N ` `=` `3` `A ` `=` `[` `1` `, ` `2` `, ` `3` `] ` `B ` `=` `[` `2` `, ` `3` `, ` `1` `] ` `print` `(commonSubarrays(A, B, N)) ` ` ` `N ` `=` `5` `A ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `] ` `B ` `=` `[` `2` `, ` `3` `, ` `1` `, ` `4` `, ` `5` `] ` `print` `(commonSubarrays(A, B, N)) ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the above approach ` `using` `System; ` `class` `GFG{ ` ` ` `static` `int` `commonSubarrays(` `int` `[]A, ` ` ` `int` `[]B, ` ` ` `int` `N) ` `{ ` ` ` ` ` `// Initialising Map for ` ` ` `// Index Mapping ` ` ` `int` `[]Map = ` `new` `int` `[N + 1]; ` ` ` ` ` `// Mapping elements of A ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `Map[A[i]] = i; ` ` ` ` ` `// Modify elements of B ` ` ` `// according to Map ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `{ ` ` ` ` ` `// Changing B[i] as ` ` ` `// the index of B[i] in A ` ` ` `B[i] = Map[B[i]]; ` ` ` `} ` ` ` ` ` `// Count of common subarrays ` ` ` `int` `count = 0; ` ` ` ` ` `// Traversing array B ` ` ` `int` `a = 0, K; ` ` ` `while` `(a < N) ` ` ` `{ ` ` ` `K = 1; ` ` ` `a += 1; ` ` ` ` ` `// While consecutive elements ` ` ` `// are found, we increment K ` ` ` `while` `(a < N && B[a] == B[a - 1] + 1) ` ` ` `{ ` ` ` `a += 1; ` ` ` `K += 1; ` ` ` `} ` ` ` ` ` `// Add number of subarrays ` ` ` `//with length K ` ` ` `// to total count ` ` ` `count = count + ((K) * (K + 1)) / 2; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main() ` `{ ` ` ` `int` `N = 3; ` ` ` `int` `[]A = {1, 2, 3}; ` ` ` `int` `[]B = {2, 3, 1}; ` ` ` `Console.Write(commonSubarrays(A, B, N)); ` ` ` `Console.Write(` `"\n"` `); ` ` ` ` ` `N = 5; ` ` ` `int` `[]C = {1, 2, 3, 4, 5}; ` ` ` `int` `[]D = {2, 3, 1, 4, 5}; ` ` ` `Console.Write(commonSubarrays(C, D, N)); ` `} ` `} ` ` ` `// This code is contributed by Code_Mech ` |

*chevron_right*

*filter_none*

**Output:**

4 7

**Time complexity:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Generate all binary permutations such that there are more or equal 1's than 0's before every point in all permutations
- Count of subarrays whose product is equal to difference of two different numbers
- Number of triangles formed by joining vertices of n-sided polygon with two common sides and no common sides
- Longest common subsequence with permutations allowed
- Print k different sorted permutations of a given array
- Minimize count of given operations required to make two given strings permutations of each other
- Minimum common element in all subarrays of size K
- Differences between number of increasing subarrays and decreasing subarrays in k sized windows
- Minimum flips in a Binary array such that XOR of consecutive subarrays of size K have different parity
- Count of common multiples of two numbers in a range
- Count common prime factors of two numbers
- Count common characters in two strings
- Count common elements in two arrays containing multiples of N and M
- Count number of common elements between two arrays by using Bitset and Bitwise operation
- Count common elements in two arrays which are in Arithmetic Progression
- Maximum count of pairwise co-prime and common divisors of two given numbers
- Minimize the sum of product of two arrays with permutations allowed
- Check if two arrays are permutations of each other
- Check if given string can be formed by two other strings or their permutations
- Check if two arrays are permutations of each other using Mathematical Operation

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.