📜  具有最大和的最长子数组

📅  最后修改于: 2021-09-22 09:52:00             🧑  作者: Mango

给定一个包含n 个整数的数组arr[] 。问题是找到具有最大和的子数组的长度。如果存在两个或多个具有最大和的子数组,则打印最长子数组的长度。
例子:

Input : arr[] = {5, -2, -1, 3, -4}
Output : 4
There are two subarrays with maximum sum:
First is {5}
Second is {5, -2, -1, 3}
Therefore longest one is of length 4.

Input : arr[] = {-2, -3, 4, -1, -2, 1, 5, -3}
Output : 5
The subarray is {4, -1, -2, 1, 5}

方法:以下是步骤:

  1. 找到最大和的连续子数组。让这个总和为maxSum
  2. 找到总和等于maxSum的最长子数组的长度。参考这个帖子。
C++
// C++ implementation to find the length of the longest
// subarray having maximum sum
#include 
using namespace std;
 
// function to find the maximum sum that
// exists in a subarray
int maxSubArraySum(int arr[], int size)
{
    int max_so_far = arr[0];
    int curr_max = arr[0];
 
    for (int i = 1; i < size; i++) {
        curr_max = max(arr[i], curr_max + arr[i]);
        max_so_far = max(max_so_far, curr_max);
    }
    return max_so_far;
}
 
// function to find the length of longest
// subarray having sum k
int lenOfLongSubarrWithGivenSum(int arr[], int n, int k)
{
    // unordered_map 'um' implemented
    // as hash table
    unordered_map um;
    int sum = 0, maxLen = 0;
 
    // traverse the given array
    for (int i = 0; i < n; i++) {
 
        // accumulate sum
        sum += arr[i];
 
        // when subarray starts from index '0'
        if (sum == k)
            maxLen = i + 1;
 
        // make an entry for 'sum' if it is
        // not present in 'um'
        if (um.find(sum) == um.end())
            um[sum] = i;
 
        // check if 'sum-k' is present in 'um'
        // or not
        if (um.find(sum - k) != um.end()) {
 
            // update maxLength
            if (maxLen < (i - um[sum - k]))
                maxLen = i - um[sum - k];
        }
    }
 
    // required maximum length
    return maxLen;
}
 
// function to find the length of the longest
// subarray having maximum sum
int lenLongSubarrWithMaxSum(int arr[], int n)
{
    int maxSum = maxSubArraySum(arr, n);
    return lenOfLongSubarrWithGivenSum(arr, n, maxSum);
}
 
// Driver program to test above
int main()
{
    int arr[] = { 5, -2, -1, 3, -4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Length of longest subarray having maximum sum = "
         << lenLongSubarrWithMaxSum(arr, n);
    return 0;
}


Java
// Java implementation to find
// the length of the longest
// subarray having maximum sum
import java.util.*;
 
class GFG
{
// function to find the
// maximum sum that
// exists in a subarray
static int maxSubArraySum(int arr[],
                          int size)
{
    int max_so_far = arr[0];
    int curr_max = arr[0];
 
    for (int i = 1; i < size; i++)
    {
        curr_max = Math.max(arr[i],
                        curr_max + arr[i]);
        max_so_far = Math.max(max_so_far,
                              curr_max);
    }
    return max_so_far;
}
 
// function to find the
// length of longest
// subarray having sum k
static int lenOfLongSubarrWithGivenSum(int arr[],
                                       int n, int k)
{
    // unordered_map 'um' implemented
    // as hash table
    HashMap um = new HashMap();
    int sum = 0, maxLen = 0;
 
    // traverse the given array
    for (int i = 0; i < n; i++)
    {
 
        // accumulate sum
        sum += arr[i];
 
        // when subarray starts
        // from index '0'
        if (sum == k)
            maxLen = i + 1;
 
        // make an entry for 'sum' if
        // it is not present in 'um'
        if (um.containsKey(sum))
            um.put(sum, i);
 
        // check if 'sum-k' is present
        // in 'um' or not
        if (um.containsKey(sum - k))
        {
 
            // update maxLength
            if (maxLen < (i - um.get(sum - k)))
                maxLen = i - um.get(sum - k);
        }
    }
 
    // required maximum length
    return maxLen;
}
 
// function to find the length
// of the longest subarray
// having maximum sum
static int lenLongSubarrWithMaxSum(int arr[], int n)
{
    int maxSum = maxSubArraySum(arr, n);
    return lenOfLongSubarrWithGivenSum(arr, n, maxSum);
}
 
// Driver Code
public static void main(String args[])
{
    int arr[] = { 5, -2, -1, 3, -4 };
    int n = arr.length;
    System.out.println("Length of longest subarray " +
                             "having maximum sum = " +
                     lenLongSubarrWithMaxSum(arr, n));
}
}
 
// This code is contributed by Arnab Kundu


Python3
# Python3 implementation to find the length
# of the longest subarray having maximum sum
 
# function to find the maximum sum that
# exists in a subarray
def maxSubArraySum(arr, size):
 
    max_so_far = arr[0]
    curr_max = arr[0]
 
    for i in range(1,size):
        curr_max = max(arr[i], curr_max + arr[i])
        max_so_far = max(max_so_far, curr_max)
    return max_so_far
 
# function to find the length of longest
# subarray having sum k
def lenOfLongSubarrWithGivenSum(arr, n, k):
 
    # unordered_map 'um' implemented
    # as hash table
    um = dict()
    Sum, maxLen = 0, 0
 
    # traverse the given array
    for i in range(n):
 
        # accumulate Sum
        Sum += arr[i]
 
        # when subarray starts from index '0'
        if (Sum == k):
            maxLen = i + 1
 
        # make an entry for 'Sum' if it is
        # not present in 'um'
        if (Sum not in um.keys()):
            um[Sum] = i
 
        # check if 'Sum-k' is present in 'um'
        # or not
        if (Sum in um.keys()):
 
            # update maxLength
            if ((Sum - k) in um.keys() and
                 maxLen < (i - um[Sum - k])):
                maxLen = i - um[Sum - k]
 
    # required maximum length
    return maxLen
 
# function to find the length of the longest
# subarray having maximum Sum
def lenLongSubarrWithMaxSum(arr, n):
 
    maxSum = maxSubArraySum(arr, n)
    return lenOfLongSubarrWithGivenSum(arr, n, maxSum)
 
# Driver Code
arr = [5, -2, -1, 3, -4]
n = len(arr)
print("Length of longest subarray having maximum sum = ",
                         lenLongSubarrWithMaxSum(arr, n))
  
# This code is contributed by mohit kumar


C#
// C# implementation to find
// the length of the longest
// subarray having maximum sum
using System;
using System.Collections.Generic;
public class GFG{
    // function to find the
    // maximum sum that
    // exists in a subarray
    static int maxSubArraySum(int []arr,
                            int size)
    {
        int max_so_far = arr[0];
        int curr_max = arr[0];
 
        for (int i = 1; i < size; i++)
        {
            curr_max = Math.Max(arr[i],
                            curr_max + arr[i]);
            max_so_far = Math.Max(max_so_far,
                                curr_max);
        }
        return max_so_far;
    }
 
    // function to find the
    // length of longest
    // subarray having sum k
    static int lenOfLongSubarrWithGivenSum(int []arr,
                                        int n, int k)
    {
        // unordered_map 'um' implemented
        // as hash table
        Dictionary um = new Dictionary();
        int sum = 0, maxLen = 0;
 
        // traverse the given array
        for (int i = 0; i < n; i++)
        {
 
            // accumulate sum
            sum += arr[i];
 
            // when subarray starts
            // from index '0'
            if (sum == k)
                maxLen = i + 1;
 
            // make an entry for 'sum' if
            // it is not present in 'um'
            if (um.ContainsKey(sum))
                um.Add(sum, i);
 
            // check if 'sum-k' is present
            // in 'um' or not
            if (um.ContainsKey(sum - k))
            {
 
                // update maxLength
                if (maxLen < (i - um[sum - k]))
                    maxLen = i - um[sum - k];
            }
        }
 
        // required maximum length
        return maxLen;
    }
 
    // function to find the length
    // of the longest subarray
    // having maximum sum
    static int lenLongSubarrWithMaxSum(int []arr, int n)
    {
        int maxSum = maxSubArraySum(arr, n);
        return lenOfLongSubarrWithGivenSum(arr, n, maxSum);
    }
 
    // Driver Code
    public static void Main()
    {
        int []arr = { 5, -2, -1, 3, -4 };
        int n = arr.Length;
        Console.WriteLine("Length of longest subarray " +
                                "having maximum sum = " +
                        lenLongSubarrWithMaxSum(arr, n));
    }
}
 
// This code is contributed by Rajput-Ji


Javascript


输出:

Length of longest subarray having maximum sum = 4

时间复杂度: O(n)。
辅助空间: O(n)。

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