Related Articles
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:

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