 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);``     ` `    ``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)

Related Topic: Subarrays, Subsequences, and Subsets in Array

My Personal Notes arrow_drop_up