Find minimum length sub-array which has given sub-sequence in it
Given an array arr[] of N elements, the task is to find the length of the smallest sub-array which has sequence {0, 1, 2, 3, 4} as a sub-sequence in it.
Examples:
Input: arr[] = {0, 1, 2, 3, 4, 2, 0, 3, 4}
Output: 5
Required Subarray is {0, 1, 2, 3, 4} with minimum length.
The entire array also contains the sequence
but it is not minimum in length.
Input: arr[] = {0, 1, 1, 0, 1, 2, 0, 3, 4}
Output: 6
Approach:
- Maintain an array pref[] of size 5 (equal to size of the sequence) where pref[i] stores the count of i in the given array till now.
- We can increase the count of pref for any number only if pref[Array[i] – 1] > 0, this is because in order to have the complete sequence as a sub-sequence of the array all the previous elements of the sequence must occur before the current. Also, store the indices of these elements found so far.
- Whenever we witness 4 i.e. the possible end of the sub-sequence and pref[3] > 0 implies that we have found the sequence in our array. Now mark that index as end as well as start point and for all other numbers in sequence from 3 to 0. Apply binary search to find their most closest index to the next element of the sequence which will get us the size of the current valid sub-array.
- Answer is the minimum size of all the valid sub-arrays found in the previous step.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; #define MAX_INT 1000000 // Function to return the minimum length // of a sub-array which contains // {0, 1, 2, 3, 4} as a sub-sequence int solve(int Array[], int N) { // To store the indices where 0, 1, 2, // 3 and 4 are present vector<int> pos[5]; // To store if there exist a valid prefix // of sequence in array int pref[5] = { 0 }; // Base Case if (Array[0] == 0) { pref[0] = 1; pos[0].push_back(0); } int ans = MAX_INT; for (int i = 1; i < N; i++) { // If current element is 0 if (Array[i] == 0) { // Update the count of 0s till now pref[0]++; // Push the index of the new 0 pos[0].push_back(i); } else { // To check if previous element of the // given sequence is found till now if (pref[Array[i] - 1] > 0) { pref[Array[i]]++; pos[Array[i]].push_back(i); // If it is the end of sequence if (Array[i] == 4) { int end = i; int start = i; // Iterate for other elements of the sequence for (int j = 3; j >= 0; j--) { int s = 0; int e = pos[j].size() - 1; int temp = -1; // Binary Search to find closest occurrence // less than equal to starting point while (s <= e) { int m = (s + e) / 2; if (pos[j][m] <= start) { temp = pos[j][m]; s = m + 1; } else { e = m - 1; } } // Update the starting point start = temp; } ans = min(ans, end - start + 1); } } } } return ans; } // Driver code int main() { int Array[] = { 0, 1, 2, 3, 4, 2, 0, 3, 4 }; int N = sizeof(Array) / sizeof(Array[0]); cout << solve(Array, N); return 0; } |
chevron_right
filter_none
Java
// Java implementation of the approach class GFG { static int MAX_INT = 1000000; // Function to return the minimum length // of a sub-array which contains // {0, 1, 2, 3, 4} as a sub-sequence static int solve(int[] array, int N) { // To store the indices where 0, 1, 2, // 3 and 4 are present int[][] pos = new int[5][10000]; // To store if there exist a valid prefix // of sequence in array int[] pref = new int[5]; // Base Case if (array[0] == 0) { pref[0] = 1; pos[0][pos[0].length - 1] = 0; } int ans = MAX_INT; for (int i = 1; i < N; i++) { // If current element is 0 if (array[i] == 0) { // Update the count of 0s till now pref[0]++; // Push the index of the new 0 pos[0][pos[0].length - 1] = i; } else { // To check if previous element of the // given sequence is found till now if (pref[array[i] - 1] > 0) { pref[array[i]]++; pos[array[i]][pos[array[i]].length - 1] = i; // If it is the end of sequence if (array[i] == 4) { int end = i; int start = i; // Iterate for other elements of the sequence for (int j = 3; j >= 0; j--) { int s = 0; int e = pos[j].length - 1; int temp = -1; // Binary Search to find closest occurrence // less than equal to starting point while (s <= e) { int m = (s + e) / 2; if (pos[j][m] <= start) { temp = pos[j][m]; s = m + 1; } else e = m - 1; } // Update the starting point start = temp; } ans = Math.min(ans, end - start + 1); } } } } return ans; } // Driver Code public static void main(String[] args) { int[] array = { 0, 1, 2, 3, 4, 2, 0, 3, 4 }; int N = array.length; System.out.println(solve(array, N)); } } // This code is contributed by // sanjeev2552 |
chevron_right
filter_none
Python3
# Python3 implementation of the approach MAX_INT=1000000 # Function to return the minimum length # of a sub-array which contains # 0, 1, 2, 3, 4 as a sub-sequence def solve(Array, N): # To store the indices where 0, 1, 2, # 3 and 4 are present pos=[[] for i in range(5)] # To store if there exist a valid prefix # of sequence in array pref=[0 for i in range(5)] # Base Case if (Array[0] == 0): pref[0] = 1 pos[0].append(0) ans = MAX_INT for i in range(N): # If current element is 0 if (Array[i] == 0): # Update the count of 0s till now pref[0]+=1 # Push the index of the new 0 pos[0].append(i) else : # To check if previous element of the # given sequence is found till now if (pref[Array[i] - 1] > 0): pref[Array[i]]+=1 pos[Array[i]].append(i) # If it is the end of sequence if (Array[i] == 4) : end = i start = i # Iterate for other elements of the sequence for j in range(3,-1,-1): s = 0 e = len(pos[j]) - 1 temp = -1 # Binary Search to find closest occurrence # less than equal to starting point while (s <= e): m = (s + e) // 2 if (pos[j][m] <= start) : temp = pos[j][m] s = m + 1 else : e = m - 1 # Update the starting point start = temp ans = min(ans, end - start + 1) return ans # Driver code Array = [ 0, 1, 2, 3, 4, 2, 0, 3, 4] N = len(Array) print(solve(Array, N)) # This code is contributed by mohit kumar 29 |
chevron_right
filter_none
C#
// C# implementation of the approach using System; class GFG { static int MAX_INT = 1000000; // Function to return the minimum length // of a sub-array which contains // {0, 1, 2, 3, 4} as a sub-sequence static int solve(int[] array, int N) { // To store the indices where 0, 1, 2, // 3 and 4 are present int[,] pos = new int[5,10000]; // To store if there exist a valid prefix // of sequence in array int[] pref = new int[5]; // Base Case if (array[0] == 0) { pref[0] = 1; pos[0,pos.GetLength(0)- 1] = 0; } int ans = MAX_INT; for (int i = 1; i < N; i++) { // If current element is 0 if (array[i] == 0) { // Update the count of 0s till now pref[0]++; // Push the index of the new 0 pos[0,pos.GetLength(0) - 1] = i; } else { // To check if previous element of the // given sequence is found till now if (pref[array[i] - 1] > 0) { pref[array[i]]++; pos[array[i],pos.GetLength(1) - 1] = i; // If it is the end of sequence if (array[i] == 4) { int end = i; int start = i; // Iterate for other elements of the sequence for (int j = 3; j >= 0; j--) { int s = 0; int e = pos.GetLength(1) - 1; int temp = -1; // Binary Search to find closest occurrence // less than equal to starting point while (s <= e) { int m = (s + e) / 2; if (pos[j,m] <= start) { temp = pos[j,m]; s = m + 1; } else e = m - 1; } // Update the starting point start = temp; } ans = Math.Min(ans, end - start + 1); } } } } return ans; } // Driver Code public static void Main(String[] args) { int[] array = { 0, 1, 2, 3, 4, 2, 0, 3, 4 }; int N = array.Length; Console.WriteLine(solve(array, N)); } } // This code is contributed by PrinciRaj1992 |
chevron_right
filter_none
Output:
5
GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details
Recommended Posts:
- Find the Minimum length Unsorted Subarray, sorting which makes the complete array sorted
- Minimum length subarray of 1s in a Binary Array
- Minimum length subarray containing all unique elements after Q operations
- Minimum cost to make Longest Common Subsequence of length k
- Subarray with difference between maximum and minimum element greater than or equal to its length
- Find the length of largest subarray with 0 sum
- Find length of longest Fibonacci like subsequence
- Find subarray of Length K with Maximum Peak
- Find maximum average subarray of k length
- Find the Increasing subsequence of length three with maximum product
- Find the length of the longest subsequence with first K alphabets having same frequency
- Find the length of largest subarray in which all elements are Autobiographical Numbers
- Find the length of the longest subarray with atmost K occurrences of the integer X
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Find the subarray of size K with minimum XOR
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.
