查找子数组 [i, N-1] 中每个索引 i 的最小子数组和

给定一个大小为N的数组arr[] ，任务是为[0, N-1 ] 中的所有i找到子数组[i, N-1]中的最小子数组和。

例子：

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

方法：这个问题可以通过使用标准的 Kadane 算法来解决最大子数组和。请按照以下步骤解决此问题：

• 反转数组arr[]的元素，即将正数变为负数，反之亦然。
• 使用变量i在[0, N-1]范围内迭代：  
  • 使用 kadane 算法找到子数组arr[i, N-1]的最大子数组和。
  • 再次反转结果并打印结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
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

 
// 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
 

输出

-5 -5 -2 4 4 

时间复杂度： O(N^2)
辅助空间： O(1)