Java Program to Find the K-th Largest Sum Contiguous Subarray
Last Updated :
13 Apr, 2023
Given an array of integers. Write a program to find the K-th largest sum of contiguous subarray within the array of numbers which has negative and positive numbers.
Examples:
Input: a[] = {20, -5, -1}
k = 3
Output: 14
Explanation: All sum of contiguous
subarrays are (20, 15, 14, -5, -6, -1)
so the 3rd largest sum is 14.
Input: a[] = {10, -10, 20, -40}
k = 6
Output: -10
Explanation: The 6th largest sum among
sum of all contiguous subarrays is -10.
A brute force approach is to store all the contiguous sums in another array and sort it and print the k-th largest. But in the case of the number of elements being large, the array in which we store the contiguous sums will run out of memory as the number of contiguous subarrays will be large (quadratic order)
An efficient approach is to store the pre-sum of the array in a sum[] array. We can find sum of contiguous subarray from index i to j as sum[j]-sum[i-1]
Now for storing the Kth largest sum, use a min heap (priority queue) in which we push the contiguous sums till we get K elements, once we have our K elements, check if the element is greater than the Kth element it is inserted to the min heap with popping out the top element in the min-heap, else not inserted. In the end, the top element in the min-heap will be your answer.
Below is the implementation of the above approach.
Java
// Java program to find the k-th
// largest sum of subarray
import java.util.*;
class KthLargestSumSubArray
{
// function to calculate kth largest
// element in contiguous subarray sum
static int kthLargestSum(int arr[], int n, int k)
{
// array to store prefix sums
int sum[] = new int[n + 1];
sum[0] = 0;
sum[1] = arr[0];
for (int i = 2; i <= n; i++)
sum[i] = sum[i - 1] + arr[i - 1];
// priority_queue of min heap
PriorityQueue<Integer> Q = new PriorityQueue<Integer> ();
// loop to calculate the contiguous subarray
// sum position-wise
for (int i = 1; i <= n; i++)
{
// loop to traverse all positions that
// form contiguous subarray
for (int j = i; j <= n; j++)
{
// calculates the contiguous subarray
// sum from j to i index
int x = sum[j] - sum[i - 1];
// if queue has less then k elements,
// then simply push it
if (Q.size() < k)
Q.add(x);
else
{
// if the min heap has equal to
// k elements then just check
// if the largest kth element is
// smaller than x then insert
// else it's of no use
if (Q.peek() < x)
{
Q.poll();
Q.add(x);
}
}
}
}
// the top element will be the kth
// largest element
return Q.poll();
}
// Driver Code
public static void main(String[] args)
{
int a[] = new int[]{ 10, -10, 20, -40 };
int n = a.length;
int k = 6;
// calls the function to find out the
// k-th largest sum
System.out.println(kthLargestSum(a, n, k));
}
}
/* This code is contributed by Danish Kaleem */
Output:
-10
Time complexity: O(n^2 log (k))
Auxiliary Space : O(n) for storing the prefix sum of the array elements
Please refer complete article on K-th Largest Sum Contiguous Subarray for more details!
Similar Reads
Java Program for Queries to find maximum sum contiguous subarrays of given length in a rotating array Given an array arr[] of N integers and Q queries of the form {X, Y} of the following two types: If X = 1, rotate the given array to the left by Y positions.If X = 2, print the maximum sum subarray of length Y in the current state of the array. Examples:Â Input: N = 5, arr[] = {1, 2, 3, 4, 5}, Q = 2,
5 min read
C++ Program to Find the K-th Largest Sum Contiguous Subarray Given an array of integers. Write a program to find the K-th largest sum of contiguous subarray within the array of numbers which has negative and positive numbers. Examples:Â Input: a[] = {20, -5, -1} k = 3 Output: 14 Explanation: All sum of contiguous subarrays are (20, 15, 14, -5, -6, -1) so the
3 min read
Python3 Program to Find the K-th Largest Sum Contiguous Subarray Given an array of integers. Write a program to find the K-th largest sum of contiguous subarray within the array of numbers which has negative and positive numbers.Examples: Input: a[] = {20, -5, -1} k = 3Output: 14Explanation: All sum of contiguous subarrays are (20, 15, 14, -5, -6, -1) so the 3rd
3 min read
Java Program for Largest Sum Contiguous Subarray Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum. Recommended: Please solve it on âPRACTICE â first, before moving on to the solution. Kadane's Algorithm: Initialize: max_so_far = INT_MIN max_ending_here = 0 Loop for
5 min read
Javascript Program for Largest Sum Contiguous Subarray Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum. Kadane's Algorithm:Initialize: max_so_far = INT_MIN max_ending_here = 0Loop for each element of the array (a) max_ending_here = max_ending_here + a[i] (b) if(max_so_f
5 min read