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

• Difficulty Level : Medium
• Last Updated : 19 Jul, 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

If flag is marked, add this count to answer

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

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

My Personal Notes arrow_drop_up