Length of longest increasing circular subarray
Given an array containing n numbers. The problem is to find the length of the longest contiguous subarray in a circular manner such that every element in the subarray is strictly greater than its previous element in the same subarray. Time Complexity should be O(n).
Examples:
Input : arr[] = {2, 3, 4, 5, 1}
Output : 5
{2, 3, 4, 5, 1} is the subarray if we circularly
start from the last element and then take the
first four elements. This will give us an increasing
subarray {1, 2, 3, 4, 5} in a circular manner.
Input : arr[] = {2, 3, 8, 4, 6, 7, 10, 12, 9, 1}
Output : 5
Method 1 (Using extra space): Make a temp[] array of size 2*n. Copy the elements of arr[] in temp[] two times. Now, find length of Longest increasing subarray in temp[].
Method 2 (Without using extra space): Following are the steps:
- If n == 1, return 1.
- Find length of longest increasing subarray starting with first element of arr[]. Let its length be startLen.
- Starting from the next element where the first increasing subarray ends, find the length of the longest increasing subarray. Let it be max.
- Consider the length of the increasing subarray that ends with the last element of arr[]. Let it be endLen.
- If arr[n-1] < arr[0], then endLen = endLen + startLen.
- Finally, return maximum of (max, endLen, startLen).
C++
// C++ implementation to find length of longest // increasing circular subarry #include <bits/stdc++.h> using namespace std; // function to find length of longest // increasing circular subarry int longlenCircularSubarr(int arr[], int n) { // if there is only one element if (n == 1) return 1; // 'startLen' stores the length of the longest // increasing subarray which starts from // first element int startLen = 1, i; int len = 1, max = 0; // finding the length of the longest // increasing subarray starting from // first element for (i = 1; i < n; i++) { if (arr[i - 1] < arr[i]) startLen++; else break; } if (max < startLen) max = startLen; // traverse the array index (i+1) for (int j = i + 1; j < n; j++) { // if current element if greater than previous // element, then this element helps in building // up the previous increasing subarray encountered // so far if (arr[j - 1] < arr[j]) len++; else { // check if 'max' length is less than the length // of the current increasing subarray. If true, // then update 'max' if (max < len) max = len; // reset 'len' to 1 as from this element // again the length of the new increasing // subarray is being calculated len = 1; } } // if true, then add length of the increasing // subarray ending at last element with the // length of the increasing subarray starting // from first element - This is done for // circular rotation if (arr[n - 1] < arr[0]) len += startLen; // check if 'max' length is less than the length // of the current increasing subarray. If true, // then update 'max' if (max < len) max = len; return max; } // Driver program to test above int main() { int arr[] = { 2, 3, 4, 5, 1 }; int n = sizeof(arr) / sizeof(arr[0]); cout << "Length = " << longlenCircularSubarr(arr, n); return 0; } |
chevron_right
filter_none
Java
// Java implementation to find length // of longest increasing circular subarry class Circular { // function to find length of longest // increasing circular subarry public static int longlenCircularSubarr(int arr[], int n) { // if there is only one element if (n == 1) return 1; // 'startLen' stores the length of the // longest increasing subarray which // starts from first element int startLen = 1, i; int len = 1, max = 0; // finding the length of the longest // increasing subarray starting from // first element for (i = 1; i < n; i++) { if (arr[i - 1] < arr[i]) startLen++; else break; } if (max < startLen) max = startLen; // traverse the array index (i+1) for (int j = i + 1; j < n; j++) { // if current element if greater than // previous element, then this element // helps in building up the previous // increasing subarray encountered so far if (arr[j - 1] < arr[j]) len++; else { // check if 'max' length is less than // the length of the current increasing // subarray. If true, then update 'max' if (max < len) max = len; // reset 'len' to 1 as from this element // again the length of the new increasing // subarray is being calculated len = 1; } } // if true, then add length of the increasing // subarray ending at last element with the // length of the increasing subarray starting // from first element - This is done for // circular rotation if (arr[n - 1] < arr[0]) len += startLen; // check if 'max' length is less than the // length of the current increasing subarray. // If true, then update 'max' if (max < len) max = len; return max; } // driver code public static void main(String[] args) { int arr[] = { 2, 3, 4, 5, 1 }; int n = 5; System.out.print("Length = "+ longlenCircularSubarr(arr, n)); } } // This code is contributed by rishabh_jain |
chevron_right
filter_none
Python3
# Python3 implementation to find length # of longest increasing circular subarry # function to find length of longest # increasing circular subarry def longlenCircularSubarr (arr, n): # if there is only one element if n == 1: return 1 # 'startLen' stores the length of the # longest increasing subarray which # starts from first element startLen = 1 len = 1 max = 0 # finding the length of the longest # increasing subarray starting from # first element for i in range(1, n): if arr[i - 1] < arr[i]: startLen+=1 else: break if max < startLen: max = startLen # traverse the array index (i+1) for j in range(i + 1, n): # if current element if greater than # previous element, then this element # helps in building up the previous # increasing subarray encountered # so far if arr[j - 1] < arr[j]: len+=1 else: # check if 'max' length is less # than the length of the current # increasing subarray. If true, # then update 'max' if max < len: max = len # reset 'len' to 1 as from this # element again the length of the # new increasing subarray is # being calculated len = 1 # if true, then add length of the increasing # subarray ending at last element with the # length of the increasing subarray starting # from first element - This is done for # circular rotation if arr[n - 1] < arr[0]: len += startLen # check if 'max' length is less than the # length of the current increasing subarray. # If true, then update 'max' if max < len: max = len return max # Driver code to test above arr = [ 2, 3, 4, 5, 1 ] n = len(arr) print("Length = ",longlenCircularSubarr(arr, n)) # This code is contributed by "Sharad_Bhardwaj". |
chevron_right
filter_none
C#
// C# implementation to find length // of longest increasing circular subarry using System; public class GFG { // function to find length of longest // increasing circular subarry static int longlenCircularSubarr(int[] arr, int n) { // if there is only one element if (n == 1) return 1; // 'startLen' stores the length of the longest // increasing subarray which starts from // first element int startLen = 1, i; int len = 1, max = 0; // finding the length of the longest // increasing subarray starting from // first element for (i = 1; i < n; i++) { if (arr[i - 1] < arr[i]) startLen++; else break; } if (max < startLen) max = startLen; // traverse the array index (i+1) for (int j = i + 1; j < n; j++) { // if current element if greater than previous // element, then this element helps in building // up the previous increasing subarray encountered // so far if (arr[j - 1] < arr[j]) len++; else { // check if 'max' length is less than the length // of the current increasing subarray. If true, // then update 'max' if (max < len) max = len; // reset 'len' to 1 as from this element // again the length of the new increasing // subarray is being calculated len = 1; } } // if true, then add length of the increasing // subarray ending at last element with the // length of the increasing subarray starting // from first element - This is done for // circular rotation if (arr[n - 1] < arr[0]) len += startLen; // check if 'max' length is less than the length // of the current increasing subarray. If true, // then update 'max' if (max < len) max = len; return max; } // Driver program to test above static public void Main() { int[] arr = { 2, 3, 4, 5, 1 }; int n = arr.Length; Console.WriteLine("Length = " + longlenCircularSubarr(arr, n)); // Code } } // This code is contributed by vt_m. |
chevron_right
filter_none
PHP
Output:
Length = 5
Time Complexity: O(n).
Recommended Posts:
- Longest increasing subarray
- Find the Longest Increasing Subsequence in Circular manner
- Longest Increasing subarray with one change allowed
- Length of the longest alternating subarray
- Length of the longest Subarray with only Even Elements
- Maximum length of subarray such that sum of the subarray is even
- Maximum circular subarray sum
- Shortest path to traverse all the elements of a circular array in increasing order
- Largest sum contiguous increasing subarray
- Find Maximum Sum Strictly Increasing Subarray
- Longest Increasing Odd Even Subsequence
- Longest Common Increasing Subsequence (LCS + LIS)
- Longest Increasing Subsequence Size (N log N)
- Longest Increasing consecutive subsequence
- Construction of Longest Increasing Subsequence (N log N)
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.
Improved By : Ita_c
- Maximum sum combination from two arrays
- Find maximum xor of k elements in an array
- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Count of elements that can be deleted without disturbing the mean of the initial array
- Introduction to Data Structures | 10 most commonly used Data Structures
- Divide the array in K segments such that the sum of minimums is maximized
- Split the given array into K sub-arrays such that maximum sum of all sub arrays is minimum
- Pair with largest sum which is less than K in the array
- Number of unique pairs in an array
- Sum of the distances from every node to all other nodes is maximum
