最小和连续子数组

给定一个包含n 个整数的数组。问题是找到具有最小(最小)和的连续子数组的元素之和。
例子：

Input : arr[] = {3, -4, 2, -3, -1, 7, -5}
Output : -6
Subarray is {-4, 2, -3, -1} = -6

Input : arr = {2, 6, 8, 1, 4}
Output : 1

朴素的方法：考虑所有不同大小的连续子数组并找到它们的总和。具有最小(最小)和的子数组是所需的答案。
高效方法：它是基于Kadane算法思想的求最大和连续子数组问题的变体。
算法：

smallestSumSubarr(arr, n)
    Initialize min_ending_here = INT_MAX
    Initialize min_so_far = INT_MAX
    
    for i = 0 to n-1
        if min_ending_here > 0
            min_ending_here = arr[i]        
        else
            min_ending_here += arr[i]
        min_so_far = min(min_so_far, min_ending_here)

    return min_so_far

C++

// C++ implementation to find the smallest sum
// contiguous subarray
#include 
 
using namespace std;
 
// function to find the smallest sum contiguous subarray
int smallestSumSubarr(int arr[], int n)
{
    // to store the minimum value that is ending
    // up to the current index
    int min_ending_here = INT_MAX;
     
    // to store the minimum value encountered so far
    int min_so_far = INT_MAX;
     
    // traverse the array elements
    for (int i=0; i 0, then it could not possibly
        // contribute to the minimum sum further
        if (min_ending_here > 0)
            min_ending_here = arr[i];
         
        // else add the value arr[i] to min_ending_here   
        else
            min_ending_here += arr[i];
         
        // update min_so_far
        min_so_far = min(min_so_far, min_ending_here);           
    }
     
    // required smallest sum contiguous subarray value
    return min_so_far;
}
 
 
// Driver program to test above
int main()
{
    int arr[] = {3, -4, 2, -3, -1, 7, -5};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Smallest sum: "
         << smallestSumSubarr(arr, n);
    return 0;    
}

Java

// Java implementation to find the smallest sum
// contiguous subarray
class GFG {
     
    // function to find the smallest sum contiguous
    // subarray
    static int smallestSumSubarr(int arr[], int n)
    {
         
        // to store the minimum value that is
        // ending up to the current index
        int min_ending_here = 2147483647;
         
        // to store the minimum value encountered
        // so far
        int min_so_far = 2147483647;
         
        // traverse the array elements
        for (int i = 0; i < n; i++)
        {
             
            // if min_ending_here > 0, then it could
            // not possibly contribute to the
            // minimum sum further
            if (min_ending_here > 0)
                min_ending_here = arr[i];
             
            // else add the value arr[i] to
            // min_ending_here
            else
                min_ending_here += arr[i];
             
            // update min_so_far
            min_so_far = Math.min(min_so_far,
                                   min_ending_here);        
        }
         
        // required smallest sum contiguous
        // subarray value
        return min_so_far;
    }
     
    // Driver method
    public static void main(String[] args)
    {
         
        int arr[] = {3, -4, 2, -3, -1, 7, -5};
        int n = arr.length;
         
        System.out.print("Smallest sum: "
                + smallestSumSubarr(arr, n));
    }
}
 
// This code is contributed by Anant Agarwal.

Python

# Python program to find the smallest sum
# contiguous subarray
import sys
 
# function to find the smallest sum
# contiguous subarray
def smallestSumSubarr(arr, n):
    # to store the minimum value that is ending
    # up to the current index
    min_ending_here = sys.maxsize
     
    # to store the minimum value encountered so far
    min_so_far = sys.maxsize
     
    # traverse the array elements
    for i in range(n):
        # if min_ending_here > 0, then it could not possibly
        # contribute to the minimum sum further
        if (min_ending_here > 0):
            min_ending_here = arr[i]
         
        # else add the value arr[i] to min_ending_here
        else:
            min_ending_here += arr[i]
          
        # update min_so_far
        min_so_far = min(min_so_far, min_ending_here)
     
    # required smallest sum contiguous subarray value
    return min_so_far
     
# Driver code
arr = [3, -4, 2, -3, -1, 7, -5]
n = len(arr)
print "Smallest sum: ", smallestSumSubarr(arr, n)
 
# This code is contributed by Sachin Bisht

C#

// C# implementation to find the
// smallest sum contiguous subarray
using System;
 
class GFG {
 
    // function to find the smallest sum
    // contiguous subarray
    static int smallestSumSubarr(int[] arr, int n)
    {
        // to store the minimum value that is
        // ending up to the current index
        int min_ending_here = 2147483647;
 
        // to store the minimum value encountered
        // so far
        int min_so_far = 2147483647;
 
        // traverse the array elements
        for (int i = 0; i < n; i++) {
 
            // if min_ending_here > 0, then it could
            // not possibly contribute to the
            // minimum sum further
            if (min_ending_here > 0)
                min_ending_here = arr[i];
 
            // else add the value arr[i] to
            // min_ending_here
            else
                min_ending_here += arr[i];
 
            // update min_so_far
            min_so_far = Math.Min(min_so_far,
                                min_ending_here);
        }
 
        // required smallest sum contiguous
        // subarray value
        return min_so_far;
    }
 
    // Driver method
    public static void Main()
    {
 
        int[] arr = { 3, -4, 2, -3, -1, 7, -5 };
        int n = arr.Length;
 
        Console.Write("Smallest sum: " +
             smallestSumSubarr(arr, n));
    }
}
 
// This code is contributed by Sam007

PHP

 0,
        // then it could not possibly
        // contribute to the minimum
        // sum further
        if ($min_ending_here > 0)
            $min_ending_here = $arr[$i];
         
        // else add the value arr[i]
        // to min_ending_here
        else
            $min_ending_here += $arr[$i];
         
        // update min_so_far
        $min_so_far = min($min_so_far,
                     $min_ending_here);        
    }
     
    // required smallest sum
    // contiguous subarray value
    return $min_so_far;
}
 
 
    // Driver Code
    $arr = array(3, -4, 2, -3, -1, 7, -5);
    $n = count($arr) ;
    echo "Smallest sum: "
         .smallestSumSubarr($arr, $n);
 
// This code is contributed by Sam007
?>

Javascript

 
    // JavaScript implementation to find the
    // smallest sum contiguous subarray
     
    // function to find the smallest sum
    // contiguous subarray
    function smallestSumSubarr(arr, n)
    {
        // to store the minimum value that is
        // ending up to the current index
        let min_ending_here = 2147483647;
   
        // to store the minimum value encountered
        // so far
        let min_so_far = 2147483647;
   
        // traverse the array elements
        for (let i = 0; i < n; i++) {
   
            // if min_ending_here > 0, then it could
            // not possibly contribute to the
            // minimum sum further
            if (min_ending_here > 0)
                min_ending_here = arr[i];
   
            // else add the value arr[i] to
            // min_ending_here
            else
                min_ending_here += arr[i];
   
            // update min_so_far
            min_so_far = Math.min(min_so_far,
                                min_ending_here);
        }
   
        // required smallest sum contiguous
        // subarray value
        return min_so_far;
    }
     
    let arr = [ 3, -4, 2, -3, -1, 7, -5 ];
    let n = arr.length;
 
    document.write("Smallest sum: " +
                  smallestSumSubarr(arr, n));
     

输出：

Smallest sum: -6

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。