First subarray having sum at least half the maximum sum of any subarray of size K
Last Updated :
25 Nov, 2021
Given an array arr[] and an integer K, the task is to find the first subarray which has a sum greater than or equal to half of the maximum possible sum from any subarray of size K.
Examples:
Input: arr[] = {2, 4, 5, 1, 4, 6, 6, 2, 1, 0}, K = 3
Output: 6 2 1
Explanation:
The given array has a maximum possible sum from any subarray of size K is 16 from the subarray {4, 6, 6}.
So, the required subarray sum should be greater than or equal to 8
{6, 2, 1} is the first subarray which has a sum of 9 which is greater than 8.
Input: arr[] = {12, 45, 11, 10, 8, 56, 2}, K = 4
Output: 45 11 10
Approach: This problem can be solved using the sliding windows technique because subarrays are to be taken into consideration. Follow the steps below to solve this problem:
- Calculate the sum of all subarrays of size K and store them in an array.
- Now, find the maximum of all the sums.
- Iterate over the array and find a sum that is greater than or equal to half of the maximum subarray sum obtained above.
- Print the subarray satisfying the above condition.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
void subArray( int arr[], int n, int k)
{
int sum = 0;
for ( int i = 0; i < k; i++) {
sum += arr[i];
}
vector< int > res;
res.push_back(sum);
for ( int i = k; i < n; i++) {
sum -= arr[i - k];
sum += arr[i];
res.push_back(sum);
}
int max_sum = *max_element(res.begin(),
res.end());
int half = max_sum / 2;
vector< int > copy = res;
sort(copy.begin(),copy.end());
int half_index, half_sum;
for ( auto x : copy) {
if (x >= half) {
half_sum = x;
break ;
}
}
for ( int x = 0; x < res.size(); x++) {
if (res[x] == half_sum) {
half_index = x;
break ;
}
}
for ( int i = 1; i <= k; i++) {
cout << arr[half_index + i - 1]
<< " " ;
}
}
int main()
{
int arr[] = { 2, 4, 5, 1, 4, 6, 6, 2, 1, 0 };
int k = 3;
int n = sizeof (arr) / sizeof (arr[0]);
subArray(arr, n, k);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void subArray( int arr[],
int n, int k)
{
int sum = 0 ;
for ( int i = 0 ; i < k; i++)
{
sum += arr[i];
}
Vector<Integer> res = new Vector<>();
res.add(sum);
for ( int i = k; i < n; i++)
{
sum -= arr[i - k];
sum += arr[i];
res.add(sum);
}
int max_sum = res.elementAt( 0 );
for ( int i = 0 ; i < res.size(); i++)
{
if (max_sum < res.elementAt(i))
{
max_sum = res.elementAt(i);
}
}
int half = max_sum / 2 ;
Vector<Integer> copy =
new Vector<>(res);
Collections.sort(copy);
int half_index = 0 , half_sum = 0 ;
for ( int x = 0 ; x < copy.size(); x++)
{
if (copy.elementAt(x) >= half)
{
half_sum = copy.elementAt(x);
break ;
}
}
for ( int x = 0 ; x < res.size(); x++)
{
if (res.elementAt(x) == half_sum)
{
half_index = x;
break ;
}
}
for ( int i = 1 ; i <= k; i++)
{
System.out.print(
arr[half_index + i - 1 ] + " " );
}
}
public static void main(String[] args)
{
int arr[] = { 2 , 4 , 5 , 1 , 4 ,
6 , 6 , 2 , 1 , 0 };
int k = 3 ;
int n = arr.length;
subArray(arr, n, k);
}
}
|
Python3
def subArray(arr, n, k):
sum = 0
for i in range (k):
sum + = arr[i]
res = []
res.append( sum )
for i in range (k, n):
sum - = arr[i - k]
sum + = arr[i]
res.append( sum )
max_sum = max (res)
half = max_sum / / 2
copy = res.copy()
copy.sort()
for x in copy:
if (x > = half):
half_sum = x
break
for x in range ( len (res)):
if (res[x] = = half_sum):
half_index = x
break
for i in range ( 1 , k + 1 ):
print (arr[half_index + i - 1 ] ,
end = " " )
if __name__ = = "__main__" :
arr = [ 2 , 4 , 5 , 1 , 4 ,
6 , 6 , 2 , 1 , 0 ]
k = 3
n = len (arr)
subArray(arr, n, k);
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void subArray( int []arr,
int n, int k)
{
int sum = 0;
for ( int i = 0; i < k; i++)
{
sum += arr[i];
}
List< int > res = new List< int >();
res.Add(sum);
for ( int i = k; i < n; i++)
{
sum -= arr[i - k];
sum += arr[i];
res.Add(sum);
}
int max_sum = res[0];
for ( int i = 0; i < res.Count; i++)
{
if (max_sum < res[i])
{
max_sum = res[i];
}
}
int half = max_sum / 2;
List< int > copy = new List< int >(res);
copy.Sort();
int half_index = 0, half_sum = 0;
for ( int x = 0; x < copy.Count; x++)
{
if (copy[x] >= half)
{
half_sum = copy[x];
break ;
}
}
for ( int x = 0; x < res.Count; x++)
{
if (res[x] == half_sum)
{
half_index = x;
break ;
}
}
for ( int i = 1; i <= k; i++)
{
Console.Write(
arr[half_index + i - 1] + " " );
}
}
public static void Main(String[] args)
{
int []arr = { 2, 4, 5, 1, 4,
6, 6, 2, 1, 0 };
int k = 3;
int n = arr.Length;
subArray(arr, n, k);
}
}
|
Javascript
<script>
function bblSort(arr){
for ( var i = 0; i < arr.length; i++){
for ( var j = 0; j < ( arr.length - i -1 ); j++){
if (arr[j] > arr[j+1]){
var temp = arr[j]
arr[j] = arr[j + 1]
arr[j+1] = temp
}
}
}
return arr;
}
function subArray(arr , n , k) {
var sum = 0;
for (i = 0; i < k; i++) {
sum += arr[i];
}
var res =[];
res.push(sum);
for (i = k; i < n; i++) {
sum -= arr[i - k];
sum += arr[i];
res.push(sum);
}
var max_sum = res[0];
for (i = 0; i < res.length; i++) {
if (max_sum < res[i]) {
max_sum = res[i];
}
}
var half = max_sum / 2;
var copy = Array(res.length).fill(0);
for (i = 0; i < res.length; i++)
copy[i] = res[i];
copy = bblSort(copy);
var half_index = 0, half_sum = 0;
for (x = 0; x < copy.length; x++) {
if (copy[x] >= half) {
half_sum = copy[x];
break ;
}
}
for (x = 0; x < res.length; x++) {
if (res[x] == half_sum) {
half_index = x;
break ;
}
}
for (i = 1; i <= k; i++) {
document.write(arr[half_index + i - 1] + " " );
}
}
var arr = [ 2, 4, 5, 1, 4, 6, 6, 2, 1, 0 ];
var k = 3;
var n = arr.length;
subArray(arr, n, k);
</script>
|
Time complexity: O(NlogN)
Space Complexity: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...