Skip to content
Related Articles

Related Articles

Find minimum subarray sum for each index i in subarray [i, N-1]

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 15 Jul, 2022
View Discussion
Improve Article
Save Article

Given an array arr[] of size N, the task is to find the minimum subarray sum in the subarrays [i, N-1] for all i in [0, N-1].

Examples:

Input: arr[ ] = {3, -1, -2}
Output: -3 -3 -2
Explanation: 
For (i = 1) i.e. {3, -1, -2}, the minimum subarray sum is -3 for {-1, -2}.
For (i = 2) i.e. {-1, -2}, the minimum subarray sum is -3 for {-1, -2}.
For (i = 3) i.e. {-2}, the minimum subarray sum is -2 for {-2}.

Input: arr[ ] = {5, -3, -2, 9, 4}
Output: -5 -5 -2 4 4

Approach: The problem can be solved by using the standard Kadane’s algorithm for maximum subarray sum. Follow the steps below to solve this problem:

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Kadane's Algorithm to find max
// sum subarray
int kadane(int arr[], int start, int end)
{
    int currMax = arr[start];
    int maxSoFar = arr[start];
 
    // Iterating from start to end
    for (int i = start + 1; i < end + 1; i++) {
 
        currMax = max(arr[i], arr[i] + currMax);
        maxSoFar = max(maxSoFar, currMax);
    }
 
    // Returning maximum sum
    return maxSoFar;
}
 
// Function to find the minimum subarray
// sum for each suffix
void minSubarraySum(int arr[], int n)
{
 
    // Inverting all the elements of
    // array arr[].
    for (int i = 0; i < n; i++) {
        arr[i] = -arr[i];
    }
 
    // Finding the result for each
    // subarray
    for (int i = 0; i < n; i++) {
 
        // Finding the max subarray sum
        int result = kadane(arr, i, n - 1);
 
        // Inverting the result
        result = -result;
 
        // Print the result
        cout << result << " ";
    }
}
 
// Driver code
int main()
{
 
    // Given Input
    int n = 5;
    int arr[] = { 5, -3, -2, 9, 4 };
 
    // Function Call
    minSubarraySum(arr, n);
 
    return 0;
}


Java




// Java program for the above approach
import java.io.*;
 
class GFG{
     
// Kadane's Algorithm to find max
// sum subarray
static int kadane(int arr[], int start, int end)
{
    int currMax = arr[start];
    int maxSoFar = arr[start];
 
    // Iterating from start to end
    for(int i = start + 1; i < end + 1; i++)
    {
        currMax = Math.max(arr[i], arr[i] + currMax);
        maxSoFar = Math.max(maxSoFar, currMax);
    }
 
    // Returning maximum sum
    return maxSoFar;
}
 
// Function to find the minimum subarray
// sum for each suffix
static void minSubarraySum(int arr[], int n)
{
     
    // Inverting all the elements of
    // array arr[].
    for(int i = 0; i < n; i++)
    {
        arr[i] = -arr[i];
    }
 
    // Finding the result for each
    // subarray
    for(int i = 0; i < n; i++)
    {
         
        // Finding the max subarray sum
        int result = kadane(arr, i, n - 1);
 
        // Inverting the result
        result = -result;
 
        // Print the result
        System.out.print(result + " ");
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given Input
    int n = 5;
    int arr[] = { 5, -3, -2, 9, 4 };
     
    // Function Call
    minSubarraySum(arr, n);
}
}
 
// This code is contributed by Potta Lokesh


Python3




# Python3 program for the above approach
 
# Kadane's Algorithm to find max
# sum subarray
def kadane(arr, start, end):
     
    currMax = arr[start]
    maxSoFar = arr[start]
 
    # Iterating from start to end
    for i in range(start + 1,end + 1, 1):
        currMax = max(arr[i], arr[i] + currMax)
        maxSoFar = max(maxSoFar, currMax)
 
    # Returning maximum sum
    return maxSoFar
 
# Function to find the minimum subarray
# sum for each suffix
def minSubarraySum(arr, n):
     
    # Inverting all the elements of
    # array arr[].
    for i in range(n):
        arr[i] = -arr[i]
 
    # Finding the result for each
    # subarray
    for i in range(n):
         
        # Finding the max subarray sum
        result = kadane(arr, i, n - 1)
 
        # Inverting the result
        result = -result
 
        # Print the result
        print(result, end = " ")
 
# Driver code
if __name__ == '__main__':
     
    # Given Input
    n = 5
    arr = [ 5, -3, -2, 9, 4 ]
 
    # Function Call
    minSubarraySum(arr, n)
     
# This code is contributed by SURENDRA_GANGWAR


C#




// C# program for the above approach
using System;
 
class GFG{
     
// Kadane's Algorithm to find max
// sum subarray
static int kadane(int []arr, int start, int end)
{
    int currMax = arr[start];
    int maxSoFar = arr[start];
 
    // Iterating from start to end
    for(int i = start + 1; i < end + 1; i++)
    {
        currMax = Math.Max(arr[i], arr[i] + currMax);
        maxSoFar = Math.Max(maxSoFar, currMax);
    }
 
    // Returning maximum sum
    return maxSoFar;
}
 
// Function to find the minimum subarray
// sum for each suffix
static void minSubarraySum(int []arr, int n)
{
     
    // Inverting all the elements of
    // array arr[].
    for(int i = 0; i < n; i++)
    {
        arr[i] = -arr[i];
    }
 
    // Finding the result for each
    // subarray
    for(int i = 0; i < n; i++)
    {
         
        // Finding the max subarray sum
        int result = kadane(arr, i, n - 1);
 
        // Inverting the result
        result = -result;
 
        // Print the result
        Console.Write(result + " ");
    }
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Given Input
    int n = 5;
    int []arr = { 5, -3, -2, 9, 4 };
     
    // Function Call
    minSubarraySum(arr, n);
}
}
 
// This code is contributed by shivanisinghss2110


Javascript




<script>
 
// Javascript program for the above approach
 
// Kadane's Algorithm to find max
// sum subarray
function kadane(arr, start, end)
{
    let currMax = arr[start];
    let maxSoFar = arr[start];
 
    // Iterating from start to end
    for(let i = start + 1; i < end + 1; i++)
    {
        currMax = Math.max(arr[i], arr[i] + currMax);
        maxSoFar = Math.max(maxSoFar, currMax);
    }
 
    // Returning maximum sum
    return maxSoFar;
}
 
// Function to find the minimum subarray
// sum for each suffix
function minSubarraySum(arr, n)
{
     
    // Inverting all the elements of
    // array arr[].
    for(let i = 0; i < n; i++)
    {
        arr[i] = -arr[i];
    }
 
    // Finding the result for each
    // subarray
    for(let i = 0; i < n; i++)
    {
         
        // Finding the max subarray sum
        let result = kadane(arr, i, n - 1);
 
        // Inverting the result
        result = -result;
 
        // Print the result
        document.write(result + " ");
    }
}
 
// Driver code
 
// Given Input
let n = 5;
let arr = [ 5, -3, -2, 9, 4 ];
 
// Function Call
minSubarraySum(arr, n);
 
// This code is contributed by gfgking
 
</script>


Output

-5 -5 -2 4 4 

Time Complexity: O(N^2)
Auxiliary Space: O(1)

Related Topic: Subarrays, Subsequences, and Subsets in Array


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!