Open in App
Not now

Longest subarray of an array which is a subsequence in another array

• Difficulty Level : Hard
• Last Updated : 11 Jul, 2022

Given two arrays arr1[] and arr2[], the task is to find the longest subarray of arr1[] which is a subsequence of arr2[].

Examples:

Input: arr1[] = {4, 2, 3, 1, 5, 6}, arr2[] = {3, 1, 4, 6, 5, 2}
Output: 3
Explanation: The longest subarray of arr1[] which is a subsequence in arr2[] is {3, 1, 5}

Input: arr1[] = {3, 2, 4, 7, 1, 5, 6, 8, 10, 9}, arr2[] = {9, 2, 4, 3, 1, 5, 6, 8, 10, 7}
Output: 5
Explanation: The longest subarray in arr1[] which is a subsequence in arr2[] is {1, 5, 6, 8, 10}.

Approach: The idea is to use Dynamic Programming to solve this problem. Follow the steps below to solve the problem:

• Initialize a DP[][] table, where DP[i][j] stores the length of the longest subarray up to the ith index in arr1[] which is a subsequence in arr2[] up to the jth index.
• Now, traverse over both the arrays and perform the following:
• Case 1: If arr1[i] and arr2[j] are equal, add 1 to DP[i – 1][j – 1] as arr1[i] and arr2[j] contributes to the required length of the longest subarray.
• Case 2: If arr1[i] and arr2[j] are not equal, set DP[i][j] = DP[i – 1][j].
• Finally, print the maximum value present in DP[][] table as the required answer.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `    ``// Function to find the length of the ` `    ``// longest subarray in arr1[] which ` `    ``// is a subsequence in arr2[] ` `    ``int` `LongSubarrSeq(``int` `arr1[], ``int` `arr2[], ``int` `M, ``int` `N) ` `    ``{ ` `        ``// Length of the array arr1[] ` ` `  `        ``// Length of the required ` `        ``// longest subarray ` `        ``int` `maxL = 0; ` ` `  `        ``// Initialize DP[]array ` `        ``int` `DP[M + 1][N + 1]; ` ` `  `        ``// Traverse array arr1[] ` `        ``for` `(``int` `i = 1; i <= M; i++) ` `        ``{ ` ` `  `            ``// Traverse array arr2[] ` `            ``for` `(``int` `j = 1; j <= N; j++) ` `            ``{ ` `                ``if` `(arr1[i - 1] == arr2[j - 1]) ` `                ``{ ` ` `  `                    ``// arr1[i - 1] contributes to ` `                    ``// the length of the subarray ` `                    ``DP[i][j] = 1 + DP[i - 1][j - 1]; ` `                ``} ` ` `  `                ``// Otherwise ` `                ``else`  `                ``{ ` ` `  `                    ``DP[i][j] = DP[i][j - 1]; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Find the maximum value ` `        ``// present in DP[][] ` `        ``for` `(``int` `i = 1; i <= M; i++)  ` `        ``{ ` `            ``for` `(``int` `j = 1; j <= N; j++) ` `            ``{ ` `                ``maxL = max(maxL, DP[i][j]); ` `            ``} ` `        ``} ` ` `  `        ``// Return the result ` `        ``return` `maxL; ` `    ``} ` ` `  ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr1[] = { 4, 2, 3, 1, 5, 6 }; ` `    ``int` `M = ``sizeof``(arr1) / ``sizeof``(arr1[0]); ` `     `  `    ``int` `arr2[] = { 3, 1, 4, 6, 5, 2 }; ` `    ``int` `N = ``sizeof``(arr2) / ``sizeof``(arr2[0]); ` ` `  `    ``// Function call to find the length ` `    ``// of the longest required subarray ` `    ``cout << LongSubarrSeq(arr1, arr2, M, N) <

Java

 `// Java program ` `// for the above approach ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to find the length of the ` `    ``// longest subarray in arr1[] which ` `    ``// is a subsequence in arr2[] ` `    ``private` `static` `int` `LongSubarrSeq( ` `        ``int``[] arr1, ``int``[] arr2) ` `    ``{ ` `        ``// Length of the array arr1[] ` `        ``int` `M = arr1.length; ` ` `  `        ``// Length of the array arr2[] ` `        ``int` `N = arr2.length; ` ` `  `        ``// Length of the required ` `        ``// longest subarray ` `        ``int` `maxL = ``0``; ` ` `  `        ``// Initialize DP[]array ` `        ``int``[][] DP = ``new` `int``[M + ``1``][N + ``1``]; ` ` `  `        ``// Traverse array arr1[] ` `        ``for` `(``int` `i = ``1``; i <= M; i++) { ` ` `  `            ``// Traverse array arr2[] ` `            ``for` `(``int` `j = ``1``; j <= N; j++) { ` ` `  `                ``if` `(arr1[i - ``1``] == arr2[j - ``1``]) { ` ` `  `                    ``// arr1[i - 1] contributes to ` `                    ``// the length of the subarray ` `                    ``DP[i][j] = ``1` `+ DP[i - ``1``][j - ``1``]; ` `                ``} ` ` `  `                ``// Otherwise ` `                ``else` `{ ` ` `  `                    ``DP[i][j] = DP[i][j - ``1``]; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Find the maximum value ` `        ``// present in DP[][] ` `        ``for` `(``int` `i = ``1``; i <= M; i++) { ` ` `  `            ``for` `(``int` `j = ``1``; j <= N; j++) { ` ` `  `                ``maxL = Math.max(maxL, DP[i][j]); ` `            ``} ` `        ``} ` ` `  `        ``// Return the result ` `        ``return` `maxL; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] arr1 = { ``4``, ``2``, ``3``, ``1``, ``5``, ``6` `}; ` `        ``int``[] arr2 = { ``3``, ``1``, ``4``, ``6``, ``5``, ``2` `}; ` ` `  `        ``// Function call to find the length ` `        ``// of the longest required subarray ` `        ``System.out.println(LongSubarrSeq(arr1, arr2)); ` `    ``} ` `}`

Python3

 `# Python program ` `# for the above approach ` ` `  `# Function to find the length of the ` `# longest subarray in arr1 which ` `# is a subsequence in arr2 ` `def` `LongSubarrSeq(arr1, arr2): ` `   `  `    ``# Length of the array arr1 ` `    ``M ``=` `len``(arr1); ` ` `  `    ``# Length of the array arr2 ` `    ``N ``=` `len``(arr2); ` ` `  `    ``# Length of the required ` `    ``# longest subarray ` `    ``maxL ``=` `0``; ` ` `  `    ``# Initialize DParray ` `    ``DP ``=` `[[``0` `for` `i ``in` `range``(N ``+` `1``)] ``for` `j ``in` `range``(M ``+` `1``)]; ` ` `  `    ``# Traverse array arr1 ` `    ``for` `i ``in` `range``(``1``, M ``+` `1``): ` ` `  `        ``# Traverse array arr2 ` `        ``for` `j ``in` `range``(``1``, N ``+` `1``): ` `            ``if` `(arr1[i ``-` `1``] ``=``=` `arr2[j ``-` `1``]): ` ` `  `                ``# arr1[i - 1] contributes to ` `                ``# the length of the subarray ` `                ``DP[i][j] ``=` `1` `+` `DP[i ``-` `1``][j ``-` `1``]; ` ` `  `            ``# Otherwise ` `            ``else``: ` ` `  `                ``DP[i][j] ``=` `DP[i][j ``-` `1``]; ` ` `  `    ``# Find the maximum value ` `    ``# present in DP ` `    ``for` `i ``in` `range``(M ``+` `1``): ` ` `  `        ``# Traverse array arr2 ` `        ``for` `j ``in` `range``(``1``, N ``+` `1``): ` `            ``maxL ``=` `max``(maxL, DP[i][j]); ` ` `  `    ``# Return the result ` `    ``return` `maxL; ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr1 ``=` `[``4``, ``2``, ``3``, ``1``, ``5``, ``6``]; ` `    ``arr2 ``=` `[``3``, ``1``, ``4``, ``6``, ``5``, ``2``]; ` ` `  `    ``# Function call to find the length ` `    ``# of the longest required subarray ` `    ``print``(LongSubarrSeq(arr1, arr2)); ` ` `  `    ``# This code contributed by shikhasingrajput`

C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to find the length of the ` `// longest subarray in arr1[] which ` `// is a subsequence in arr2[] ` `private` `static` `int` `LongSubarrSeq(``int``[] arr1,  ` `                                 ``int``[] arr2) ` `{ ` `     `  `    ``// Length of the array arr1[] ` `    ``int` `M = arr1.Length; ` `     `  `    ``// Length of the array arr2[] ` `    ``int` `N = arr2.Length; ` `     `  `    ``// Length of the required ` `    ``// longest subarray ` `    ``int` `maxL = 0; ` `     `  `    ``// Initialize DP[]array ` `    ``int``[,] DP = ``new` `int``[M + 1, N + 1]; ` ` `  `    ``// Traverse array arr1[] ` `    ``for``(``int` `i = 1; i <= M; i++)  ` `    ``{ ` `         `  `        ``// Traverse array arr2[] ` `        ``for``(``int` `j = 1; j <= N; j++)  ` `        ``{ ` `            ``if` `(arr1[i - 1] == arr2[j - 1]) ` `            ``{ ` `                 `  `                ``// arr1[i - 1] contributes to ` `                ``// the length of the subarray ` `                ``DP[i, j] = 1 + DP[i - 1, j - 1]; ` `            ``} ` ` `  `            ``// Otherwise ` `            ``else`  `            ``{ ` `                ``DP[i, j] = DP[i, j - 1]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Find the maximum value ` `    ``// present in DP[][] ` `    ``for``(``int` `i = 1; i <= M; i++)  ` `    ``{ ` `        ``for``(``int` `j = 1; j <= N; j++)  ` `        ``{ ` `            ``maxL = Math.Max(maxL, DP[i, j]); ` `        ``} ` `    ``} ` `     `  `    ``// Return the result ` `    ``return` `maxL; ` `} ` ` `  `// Driver Code ` `static` `public` `void` `Main() ` `{ ` `    ``int``[] arr1 = { 4, 2, 3, 1, 5, 6 }; ` `    ``int``[] arr2 = { 3, 1, 4, 6, 5, 2 }; ` `     `  `    ``// Function call to find the length ` `    ``// of the longest required subarray ` `    ``Console.WriteLine(LongSubarrSeq(arr1, arr2)); ` `} ` `} ` ` `  `// This code is contributed by susmitakundugoaldanga`

Javascript

 ``

Output:

`3`

Time Complexity: O(M * N)
Auxiliary Space: O(M * N)

Related Topic: Subarrays, Subsequences, and Subsets in Array

My Personal Notes arrow_drop_up
Related Articles