排除最大元素后总和最大的子数组

给定一个数组arr[] ，任务是找到排除其最大元素后具有最大总和的子数组的开始和结束索引。
例子：

Input: arr[] = {5, -2, 10, -1, 4} 
Output: 1 5 
Explanation: 
Subarray[1:5] = {5, -2, 10, -1, 4} 
Sum of subarray excluding maximum element = 5 + (-2) + (-1) + 4 = 6
Input: arr[] = {5, 2, 5, 3, -30, -30, 6, 9} 
Output: 1 4 
Explanation: 
Subarray[1:4] = {5, 2, 5, 3} 
Sum of subarray excluding maximum element = 5 + 2 + 3 = 10 
 

做法：思路是用Kadane算法来解决这个问题。

1. 在这个问题中，我们必须选择一个元素，它是子数组中的最大值。
2. 因此，我们可以从数组中选择所有正元素，并且每次我们可以将大于该元素的元素设置为INT_MIN，这样它就不会被包含在数组中。
3. 最后，应用 Kadane 算法找到最大和子数组。
4. 如果数组中没有正元素，那么我们可以从数组中选择任何一个元素，以获得最大和为 0。

下面是上述方法的实现：

C++

// C++ implementation to find the
// maximum sum subarray such by
// excluding the maximum element
// from the subarray
 
#include 
using namespace std;
 
// Function to find the maximum sum
// subarray by excluding the maximum
// element from the array
void maximumSumSubarray(int arr[], int n)
{
    unordered_map mp;
 
    // Loop to store all the positive
    // elements in the map
    for (int i = 0; i < n; i++) {
 
        if (arr[i] >= 0
            && mp.find(arr[i])
                == mp.end())
 
            mp[arr[i]] = 1;
    }
 
    int first = 0;
    int last = 0;
    int ans = 0;
    int INF = 1e6;
 
    // Loop to iterating over the map
    // and considering as the maximum
    // element of the current including
    // subarray
    for (auto i : mp) {
 
        // Make the current
        // element maximum
        int mx = i.first;
 
        int curr = 0;
        int curr_start;
 
        // Iterate through array and
        // apply kadane's algorithm
        for (int j = 0; j < n; j++) {
            if (curr == 0)
                curr_start = j;
 
            // Condition if current element is
            // greater than mx then make
            // the element -infinity
            int val = arr[j] > mx
                        ? -INF
                        : arr[j];
 
            curr += val;
 
            if (curr < 0)
                curr = 0;
 
            if (curr > ans) {
                ans = curr;
 
                // Store the indices
                // in some variable
                first = curr_start;
                last = j;
            }
        }
    }
 
    cout << first + 1
        << " " << last + 1;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, -2, 10, -1, 4 };
 
    int size = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    maximumSumSubarray(arr, size);
    return 0;
}

Java

// Java implementation to find the
// maximum sum subarray such by
// excluding the maximum element
// from the subarray
import java.util.*;
 
class GFG{
     
// Function to find the maximum sum
// subarray by excluding the maximum
// element from the array
static void maximumSumSubarray(int arr[], int n)
{
    Map mp = new HashMap<>();
     
    // Loop to store all the positive
    // elements in the map
    for(int i = 0; i < n; i++)
    {
        if (arr[i] >= 0)
            mp.put(arr[i], 1);
    }
     
    int first = 0;
    int last = 0;
    int ans = 0;
    int INF = (int)1e6;
     
    // Loop to iterating over the map
    // and considering as the maximum
    // element of the current including
    // subarray
    for (Map.Entry i : mp.entrySet())
    {
         
        // Make the current
        // element maximum
        int mx = i.getKey();
        int curr = 0;
        int curr_start = -1;
         
        // Iterate through array and
        // apply kadane's algorithm
        for(int j = 0; j < n; j++)
        {
            if (curr == 0)
                curr_start = j;
                 
            // Condition if current element is
            // greater than mx then make
            // the element -infinity
            int val = arr[j] > mx ? -INF : arr[j];
            curr += val;
             
            if (curr < 0)
                curr = 0;
             
            if (curr > ans)
            {
                ans = curr;
                 
                // Store the indices
                // in some variable
                first = curr_start;
                last = j;
            }
        }
    }
    System.out.print((first + 1) + " " +
                      (last + 1));
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 5, -2, 10, -1, 4 };
    int size = arr.length;
     
    // Function call
    maximumSumSubarray(arr, size);
}
}
 
// This code is contributed by offbeat

Python3

# Python3 implementation to find
# the maximum sum subarray such
# by excluding the maximum
# element from the subarray
 
# Function to find the maximum sum
# subarray by excluding the maximum
# element from the array
def maximumSumSubarray(arr, n):
    mp = {}
 
    # Loop to store all the positive
    # elements in the map
    for i in range(n):
 
        if (arr[i] >= 0 and
            arr[i] not in mp):
            mp[arr[i]] = 1
 
    first = 0
    last = 0
    ans = 0
    INF = 1e6
 
    # Loop to iterating over the map
    # and considering as the maximum
    # element of the current including
    # subarray
    for i in mp:
 
        # Make the current
        # element maximum
        mx = i
 
        curr = 0
 
        # Iterate through array and
        # apply kadane's algorithm
        for j in range(n):
            if (curr == 0):
                curr_start = j
 
            # Condition if current element
            # is greater than mx then make
            # the element -infinity
            if arr[j] > mx:
                val =- INF
            else:
                val= arr[j];
 
            curr += val
 
            if (curr < 0):
                curr = 0
 
            if (curr > ans):
                ans = curr
 
                # Store the indices
                # in some variable
                first = curr_start
                last = j
 
    print(first + 1, last + 1)
 
# Driver Code
if __name__ == "__main__":
     
    arr = [ 5, -2, 10, -1, 4 ]
    size = len(arr)
 
    # Function Call
    maximumSumSubarray(arr, size)
 
# This code is contributed by chitranayal

C#

// C# implementation to find the
// maximum sum subarray such by
// excluding the maximum element
// from the subarray
using System;
using System.Collections.Generic;
class GFG{
     
// Function to find the maximum sum
// subarray by excluding the maximum
// element from the array
static void maximumSumSubarray(int []arr,
                               int n)
{
  Dictionary mp = new Dictionary();
 
  // Loop to store all the positive
  // elements in the map
  for(int i = 0; i < n; i++)
  {
    if (arr[i] >= 0)
      mp.Add(arr[i], 1);
  }
 
  int first = 0;
  int last = 0;
  int ans = 0;
  int INF = (int)1e6;
 
  // Loop to iterating over the map
  // and considering as the maximum
  // element of the current including
  // subarray
  foreach (KeyValuePair i in mp)
  {
    // Make the current
    // element maximum
    int mx = i.Key;
    int curr = 0;
    int curr_start = -1;
 
    // Iterate through array and
    // apply kadane's algorithm
    for(int j = 0; j < n; j++)
    {
      if (curr == 0)
        curr_start = j;
 
      // Condition if current element is
      // greater than mx then make
      // the element -infinity
      int val = arr[j] > mx ?
                -INF : arr[j];
      curr += val;
 
      if (curr < 0)
        curr = 0;
 
      if (curr > ans)
      {
        ans = curr;
 
        // Store the indices
        // in some variable
        first = curr_start;
        last = j;
      }
    }
  }
  Console.Write((first + 1) + " " +
                (last + 1));
}
 
// Driver code
public static void Main(String[] args)
{
  int []arr = {5, -2, 10, -1, 4};
  int size = arr.Length;
 
  // Function call
  maximumSumSubarray(arr, size);
}
}
 
// This code is contributed by shikhasingrajput

Javascript

 
// JavaScript implementation to find the
// maximum sum subarray such by
// excluding the maximum element
// from the subarray
 
 
// Function to find the maximum sum
// subarray by excluding the maximum
// element from the array
function maximumSumSubarray(arr, n)
{
    var mp = new Map();
 
    // Loop to store all the positive
    // elements in the map
    for (var i = 0; i < n; i++) {
 
        if (arr[i] >= 0
            && !mp.has(arr[i]))
            mp.set(arr[i] , 1);
    }
 
    var first = 0;
    var last = 0;
    var ans = 0;
    var INF = 1000000;
 
    // Loop to iterating over the map
    // and considering as the maximum
    // element of the current including
    // subarray
    mp.forEach((value, key) => {
         
        // Make the current
        // element maximum
        var mx = key;
 
        var curr = 0;
        var curr_start;
 
        // Iterate through array and
        // apply kadane's algorithm
        for (var j = 0; j < n; j++) {
            if (curr == 0)
                curr_start = j;
 
            // Condition if current element is
            // greater than mx then make
            // the element -infinity
            var val = arr[j] > mx
                        ? -INF
                        : arr[j];
 
            curr += val;
 
            if (curr < 0)
                curr = 0;
 
            if (curr > ans) {
                ans = curr;
 
                // Store the indices
                // in some variable
                first = curr_start;
                last = j;
            }
        }
    });
 
    document.write( first + 1
        + " " + (last + 1));
}
 
// Driver Code
 
var arr = [5, -2, 10, -1, 4];
var size = arr.length;
 
// Function Call
maximumSumSubarray(arr, size);
 
 

输出：

1 5

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