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

• Difficulty Level : Hard
• Last Updated : 03 May, 2021

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

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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);``    ` `    ``int` `arr2[] = { 3, 1, 4, 6, 5, 2 };``    ``int` `N = ``sizeof``(arr2) / ``sizeof``(arr2);` `    ``// 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)

My Personal Notes arrow_drop_up