# Maximum sum of lengths of non-overlapping subarrays with k as the max element.

Last Updated : 12 Oct, 2022

Find the maximum sum of lengths of non-overlapping subarrays (contiguous elements) with k as the maximum element.

Examples:

```Input : arr[] = {2, 1, 4, 9, 2, 3, 8, 3, 4}
k = 4
Output : 5
{2, 1, 4} => Length = 3
{3, 4} => Length = 2
So, 3 + 2 = 5 is the answer

Input : arr[] = {1, 2, 3, 2, 3, 4, 1}
k = 4
Output : 7
{1, 2, 3, 2, 3, 4, 1} => Length = 7

Input : arr = {4, 5, 7, 1, 2, 9, 8, 4, 3, 1}
k = 4
Ans = 4
{4} => Length = 1
{4, 3, 1} => Length = 3
So, 1 + 3 = 4 is the answer```

Algorithm :

```Traverse the array starting from first element
Take a loop and keep on incrementing count
If element is less than equal to k
if array element is equal to k, then mark
a flag

Take another loop and traverse the array
till element is greater than k
return ans```

Implementation:

## C++

 `// CPP program to calculate max sum lengths of` `// non overlapping contiguous subarrays with k as` `// max element` `#include ` `using` `namespace` `std;` ` `  `// Returns max sum of lengths with maximum element` `// as k` `int` `calculateMaxSumLength(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``int` `ans = 0; ``// final sum of lengths` ` `  `    ``// number of elements in current subarray` `    ``int` `count = 0; ` ` `  `    ``// variable for checking if k appeared in subarray` `    ``int` `flag = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n;) {` `        ``count = 0;` `        ``flag = 0;` ` `  `        ``// count the number of elements which are` `        ``// less than equal to k` `        ``while` `(arr[i] <= k && i < n) {` `            ``count++;` `            ``if` `(arr[i] == k)` `                ``flag = 1;` `            ``i++;` `        ``}` ` `  `        ``// if current element appeared in current ` `        ``// subarray add count to sumLength` `        ``if` `(flag == 1) ` `            ``ans += count;    ` ` `  `        ``// skip the array elements which are ` `        ``// greater than k` `        ``while` `(arr[i] > k && i < n) ` `            ``i++;     ` `    ``}` `    ``return` `ans;` `}` ` `  `// driver program` `int` `main()` `{` `    ``int` `arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `k = 4;` `    ``int` `ans = calculateMaxSumLength(arr, size, k);` `    ``cout << ``"Max Length :: "` `<< ans << endl;` `    ``return` `0;` `}`

## Java

 `// A Java program to calculate max sum lengths of` `// non overlapping contiguous subarrays with k as` `// max element` `public` `class` `GFG` `{` `    ``// Returns max sum of lengths with maximum element` `    ``// as k` `    ``static` `int` `calculateMaxSumLength(``int` `arr[], ``int` `n, ``int` `k) {` `        ``int` `ans = ``0``; ``// final sum of lengths`   `        ``// number of elements in current subarray` `        ``int` `count = ``0``;`   `        ``// variable for checking if k appeared in subarray` `        ``int` `flag = ``0``;`   `        ``for` `(``int` `i = ``0``; i < n;) {` `            ``count = ``0``;` `            ``flag = ``0``;`   `            ``// count the number of elements which are` `            ``// less than equal to k` `            ``while` `(i < n && arr[i] <= k) {` `                ``count++;` `                ``if` `(arr[i] == k)` `                    ``flag = ``1``;` `                ``i++;` `            ``}`   `            ``// if current element appeared in current` `            ``// subarray add count to sumLength` `            ``if` `(flag == ``1``)` `                ``ans += count;`   `            ``// skip the array elements which are` `            ``// greater than k` `            ``while` `(i < n && arr[i] > k)` `                ``i++;` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// driver program to test above method` `    ``public` `static` `void` `main(String[] args) {`   `        ``int` `arr[] = { ``4``, ``5``, ``7``, ``1``, ``2``, ``9``, ``8``, ``4``, ``3``, ``1` `};` `        ``int` `size = arr.length;` `        ``int` `k = ``4``;` `        ``int` `ans = calculateMaxSumLength(arr, size, k);` `        ``System.out.println(``"Max Length :: "` `+ ans);` `    ``}` `}` `// This code is contributed by Sumit Ghosh`

## Python3

 `# Python program to calculate max sum lengths of non` `# overlapping contiguous subarrays with k as max element`   `# Returns max sum of lengths with max elements as k` `def` `calculateMaxSumLength(arr, n, k):` `    ``ans ``=` `0` `# final sum of lengths` `    ``i``=``0` `    ``while` `i < n :` `        `  `        ``# number of elements in current sub array` `        ``count ``=` `0` `        `  `        ``# Variable for checking if k appeared in the sub array` `        ``flag ``=` `0` `        `  `        ``# Count the number of elements which are` `        ``# less than or equal to k ` `        ``while` `i < n ``and` `arr[i] <``=` `k :` `            ``count ``=` `count ``+` `1` `            ``if` `arr[i] ``=``=` `k:` `                ``flag ``=` `1` `            ``i ``=` `i ``+` `1` `            `  `        ``# if current element appeared in current` `        ``# subarray and count to sumLength` `        ``if` `flag ``=``=` `1``:` `            ``ans ``=` `ans ``+` `count` `            `  `        ``# skip the array elements which are greater than k` `        ``while` `i < n ``and` `arr[i] > k :` `            ``i ``=` `i ``+` `1` `             `  `    ``return` `ans` `    `  `# Driver Program` `arr ``=` `[``4``, ``5``, ``7``, ``1``, ``2``, ``9``, ``8``, ``4``, ``3``, ``1``]` `size ``=` `len``(arr)` `k ``=` `4` `ans ``=` `calculateMaxSumLength(arr, size, k)` `print` `(``"Max Length ::"``,ans)`   `# Contributed by Rohit`

## C#

 `// A C# program to calculate max ` `// sum lengths of non overlapping` `// contiguous subarrays with k as` `// max element` `using` `System;` `class` `GFG {` `    `  `    ``// Returns max sum of lengths ` `    ``// with maximum element as k` `    ``static` `int` `calculateMaxSumLength(``int` `[]arr,` `                                     ``int` `n, ` `                                     ``int` `k) ` `    ``{` `        `  `        ``// final sum of lengths` `        ``int` `ans = 0; `   `        ``// number of elements in ` `        ``// current subarray` `        ``int` `count = 0;`   `        ``// variable for checking if` `        ``// k appeared in subarray` `        ``int` `flag = 0;`   `        ``for``(``int` `i = 0; i < n;) ` `        ``{` `            ``count = 0;` `            ``flag = 0;`   `            ``// count the number of ` `            ``// elements which are` `            ``// less than equal to k` `            ``while` `(i < n && arr[i] <= k)` `            ``{` `                ``count++;` `                ``if` `(arr[i] == k)` `                    ``flag = 1;` `                ``i++;` `            ``}`   `            ``// if current element ` `            ``// appeared in current` `            ``// subarray add count ` `            ``// to sumLength` `            ``if` `(flag == 1)` `                ``ans += count;`   `            ``// skip the array ` `            ``// elements which are` `            ``// greater than k` `            ``while` `(i < n && arr[i] > k)` `                ``i++;` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main() ` `    ``{` `        ``int` `[]arr = {4, 5, 7, 1, 2, 9, 8, 4, 3, 1};` `        ``int` `size = arr.Length;` `        ``int` `k = 4;` `        ``int` `ans = calculateMaxSumLength(arr, size, k);` `        ``Console.WriteLine(``"Max Length :: "` `+ ans);` `    ``}` `}`   `// This code is contributed by anuj_67.`

## PHP

 ` ``\$k` `&& ``\$i` `< ``\$n``) ` `            ``\$i``++;     ` `    ``}` `    ``return` `\$ans``;` `}`   `// Driver Code` `\$arr` `= ``array``( 4, 5, 7, 1, 2,    ` `              ``9, 8, 4, 3, 1 );` `\$size` `= sizeof(``\$arr``);` `\$k` `= 4;` `\$ans` `= calculateMaxSumLength(``\$arr``, ``\$size``, ``\$k``);` `echo` `"Max Length :: "` `. ``\$ans` `. ``"\n"``;`   `// This code is contributed by ita_c` `?>`

## Javascript

 ``

Output

`Max Length :: 4`

Time Complexity: O(n), It may look like O(n2), but if you take a closer look, array is traversed only once
Auxiliary Space: O(1)

#### Another approach:

Algorithm:

```Traverse the array from first element to last element
if the element is less than k increment the count
if the element is equals to k
increment the count and mark flag as 1
if k is found
add the value of count to ans and mark count as 1
if the element is greater than k
if k is present in the subarray add the value of count to ans and
assign value of count and flag variables as 0
finally check again if k value is found in subarray or not
if k is found return sum of answer and count
if not return ans```

Implementation:

## C++

 `// C++ program to find Maximum sum of lengths of` `// non-overlapping subarrays with k as the max element.` `#include ` `using` `namespace` `std;` `// Below function calculates the Maximum sum of lengths of` `// non-overlapping subarrays with k as the max element.` `int` `calculateMaxSumLength(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// maximum sum of lengths` `    ``int` `ans = 0;` `    ``// number of elements in current subarray` `    ``int` `count = 0;` `    ``// flag variable for checking if k is present` `    ``// in current subarray or not` `    ``int` `flag = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// increment the count if element in arr is less` `        ``// than k` `        ``if` `(arr[i] < k) {` `            ``count++;` `        ``}` `        ``// if the element is equals to k` `        ``else` `if` `(arr[i] == k) {` `            ``if` `(flag == 0) {` `                ``count++;` `                ``flag = 1;` `            ``}` `            ``// if flag is 1, we can say k is already present` `            ``// in that subarray. So, add the value of count` `            ``// to ans variable and make the count value as 1` `            ``// because we found the k` `            ``else` `{` `                ``ans += count;` `                ``count = 1;` `            ``}` `        ``}` `        ``// if element in arr is greater than k` `        ``else` `{` `            ``// if k is present in the subarray` `            ``// add the value of count to ans variable` `            ``if` `(flag == 1) {` `                ``ans += count;` `            ``}` `            ``// assign value of count and flag variables as 0` `            ``count = 0;` `            ``flag = 0;` `        ``}` `    ``}` `    ``// Check again if k value is found in subarray` `    ``// if k is found, return sum of values of variables ans` `    ``// and count if k is not found, return value of variable` `    ``// ans.` `    ``if` `(flag == 1) {` `        ``return` `ans + count;` `    ``}` `    ``return` `ans;` `}` `// driver program` `int` `main()` `{` `    ``int` `arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `k = 4;` `    ``int` `ans = calculateMaxSumLength(arr, size, k);` `    ``cout << ``"Max Length :: "` `<< ans << endl;` `    ``return` `0;` `}` `// Contributed by Ravi Teja Kuchipudi`

## Java

 `// JAVA program to find Maximum sum of lengths of` `// non-overlapping subarrays with k as the max element.` `class` `GFG {` `    ``// Below function calculates the Maximum sum of lengths` `    ``// of non-overlapping subarrays with k as the max` `    ``// element.` `    ``static` `int` `calculateMaxSumLength(``int` `arr[], ``int` `n,` `                                     ``int` `k)` `    ``{` `        ``// maximum sum of lengths` `        ``int` `ans = ``0``;` `        ``// number of elements in current subarray` `        ``int` `count = ``0``;` `        ``// flag variable for checking if k is present` `        ``// in current subarray or not` `        ``int` `flag = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// increment the count if element in arr is less` `            ``// than k` `            ``if` `(arr[i] < k) {` `                ``count++;` `            ``}` `            ``// if the element is equals to k` `            ``else` `if` `(arr[i] == k) {` `                ``// if flag is equals to 0 then make flag` `                ``// variable value as 1 and increment the` `                ``// count.` `                ``if` `(flag == ``0``) {` `                    ``count++;` `                    ``flag = ``1``;` `                ``}` `                ``// if flag is 1, we can say k is already` `                ``// present in that subarray. So, add the` `                ``// value of count to ans variable and make` `                ``// the count value as 1 because we found the` `                ``// k` `                ``else` `{` `                    ``ans += count;` `                    ``count = ``1``;` `                ``}` `            ``}` `            ``// if element in arr is greater than k` `            ``else` `{` `                ``// if k is present in the subarray` `                ``// add the value of count to ans variable` `                ``if` `(flag == ``1``) {` `                    ``ans += count;` `                ``}` `                ``// assign value of count and flag variables` `                ``// as 0` `                ``count = ``0``;` `                ``flag = ``0``;` `            ``}` `        ``}` `        ``// Check again if k value is found in subarray` `        ``// if k is found, return sum of values of variables` `        ``// ans and count if k is not found, return value of` `        ``// variable ans.` `        ``if` `(flag == ``1``) {` `            ``return` `ans + count;` `        ``}` `        ``return` `ans;` `    ``}` `    ``// driver program to test above method` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``4``, ``5``, ``7``, ``1``, ``2``, ``9``, ``8``, ``4``, ``3``, ``1` `};` `        ``int` `size = arr.length;` `        ``int` `k = ``4``;` `        ``int` `ans = calculateMaxSumLength(arr, size, k);` `        ``System.out.println(``"Max Length :: "` `+ ans);` `    ``}` `}` `// Contributed by Ravi Teja Kuchipudi`

## Python3

 `# program to find Maximum sum of lengths of` `# non-overlapping subarrays with k as the max element.`     `def` `calculateMaxSumLength(arr, n, k):` `    ``# maximum sum of lengths` `    ``ans ``=` `0` `    ``# number of elements in current subarray` `    ``count ``=` `0` `    ``# flag variable for checking if k is present in current subarray or not` `    ``flag ``=` `0`   `    ``for` `i ``in` `range``(n):` `        ``# increment the count if element in arr is less than k` `        ``if` `arr[i] < k:` `            ``count ``=` `count``+``1` `        ``# if the element is equals to k` `        ``elif` `arr[i] ``=``=` `k:` `            ``# if flag is equals to 0 then make flag variable value as 1 and` `            ``# increment the count.` `            ``if` `flag ``=``=` `0``:` `                ``count ``=` `count ``+` `1` `                ``flag ``=` `1` `            ``# if flag is 1, we can say k is already present in that subarray.` `            ``# So, add the value of count to ans variable and` `            ``# make the count value as 1 because we found the k` `            ``else``:` `                ``ans ``=` `ans ``+` `count` `                ``count ``=` `1` `        ``# if element in arr is greater than k` `        ``else``:` `            ``# if k is present in the subarray` `            ``# add the value of count to ans variable` `            ``if` `flag ``=``=` `1``:` `                ``ans ``=` `ans ``+` `count` `            ``# assign value of count and flag variables as 0` `            ``count ``=` `0` `            ``flag ``=` `0` `    ``# Check again if k value is found in subarray` `    ``# if k is found, return sum of values of variables ans and count` `    ``# if k is not found, return value of variable ans.` `    ``if` `flag ``=``=` `1``:` `        ``return` `ans ``+` `count` `    ``return` `ans`     `# Driver Program` `arr ``=` `[``4``, ``5``, ``7``, ``1``, ``2``, ``9``, ``8``, ``4``, ``3``, ``1``]` `size ``=` `len``(arr)` `k ``=` `4` `ans ``=` `calculateMaxSumLength(arr, size, k)` `print``(``"Max Length ::"``, ans)`   `# Contributed by Ravi Teja Kuchipudi`

## C#

 `// C# program to find Maximum sum of lengths of` `// non-overlapping subarrays with k as the max element.` `using` `System;` `class` `GFG ` `{` `    ``// Returns max sum of lengths` `    ``// with maximum element as k` `    ``static` `int` `calculateMaxSumLength(``int``[] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// maximum sum of lengths` `        ``int` `ans = 0;` `        ``// number of elements in current subarray` `        ``int` `count = 0;` `        ``// flag variable for checking if k is present` `        ``// in current subarray or not` `        ``int` `flag = 0;` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``// increment the count if element in arr is less` `            ``// than k` `            ``if` `(arr[i] < k) ` `            ``{` `                ``count++;` `            ``}` `            ``// if the element is equals to k` `            ``else` `if` `(arr[i] == k) ` `            ``{` `                ``// if flag is equals to 0 then make flag` `                ``// variable value as 1 and increment the` `                ``// count.` `                ``if` `(flag == 0) ` `                ``{` `                    ``count++;` `                    ``flag = 1;` `                ``}` `                ``// if flag is 1, we can say k is already` `                ``// present in that subarray. So, add the` `                ``// value of count to ans variable and make` `                ``// the count value as 1 because we found the` `                ``// k` `                ``else` `                ``{` `                    ``ans += count;` `                    ``count = 1;` `                ``}` `            ``}` `            ``// if element in arr is greater than k` `            ``else` `            ``{` `                ``// if k is present in the subarray` `                ``// add the value of count to ans variable` `                ``if` `(flag == 1) ` `                ``{` `                    ``ans += count;` `                ``}` `                ``// assign value of count and flag variables` `                ``// as 0` `                ``count = 0;` `                ``flag = 0;` `            ``}` `        ``}` `        ``// Check again if k value is found in subarray` `        ``// if k is found, return sum of values of variables` `        ``// ans and count if k is not found, return value of` `        ``// variable ans.` `        ``if` `(flag == 1) ` `        ``{` `            ``return` `ans + count;` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]arr = {4, 5, 7, 1, 2, 9, 8, 4, 3, 1};` `        ``int` `size = arr.Length;` `        ``int` `k = 4;` `        ``int` `ans = calculateMaxSumLength(arr, size, k);` `        ``Console.WriteLine(``"Max Length :: "` `+ ans);` `    ``}` `}`   `// This code is contributed by kothavvsaakash`

## Javascript

 ``

Output

`Max Length :: 4`

Time Complexity: O(n)
Auxiliary Space: O(1)

Previous
Next