给定数组的第一个子数组的总和为负

给定一个由N个整数组成的数组arr [] ，任务是使用负和找到第一个子数组的开始和结束索引。如果不存在这样的子数组，则打印“ -1”。

注意：在给定数组中有多个负和子数组的情况下，第一个子数组是指起始索引最低的子数组。

例子：

Input: arr[] = {3, 3, -4, -2}
Output: 1 2
Explanation:
The first subarray with negative sum is from index 1 to 2 that is arr[1] + arr[2] = -1.

Input: arr[] = {1, 2, 3, 10}.
Output: -1
Explanation:
No Subarray with negative sum exists.

天真的方法：天真的方法是生成数组中从左到右的所有子数组，并检查这些子数组中的任何一个是否具有负和。如果是，则打印该子数组的开始和结束索引。

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

高效的方法：想法是使用“前缀总和”和“哈希”解决问题。步骤如下：

1. 计算数组的前缀和，并将其存储到HashMap中。
2. 遍历数组，并对于^第i个索引(其中i的范围为[0，N – 1])^{进行迭代，检查第}i个索引处的元素是否为负。如果是这样，则arr [i]是必需的子数组。
3. 否则，找到一个从i +1开始的索引，其中前缀和小于前缀和直到i 。
4. 如果在上述步骤中找到任何这样的索引，则索引{i，index}的子数组将给出第一个负子数组。
5. 如果找不到这样的子数组，则打印“ -1” 。否则，打印获得的子数组。

下面是上述方法的实现：

C++

// CPP program for the above approach
#include 
using namespace std;
  
// Function to check if a sum less
// than pre_sum is present
int b_search(int pre_sum,
             map >& m,
             int index)
{
    // Returns an iterator either equal
    // to given key or next greater
    auto it = m.lower_bound(pre_sum);
  
    if (it == m.begin())
        return -1;
  
    // Decrement the iterator
    it--;
  
    // Check if the sum found at
    // a greater index
    auto it1
        = lower_bound(it->second.begin(),
                      it->second.end(),
                      index);
  
    if (*it1 > index)
        return *it1;
  
    return -1;
}
  
// Function to return the index
// of first negative subarray sum
vector findSubarray(int arr[], int n)
{
    // Stores the prefix sum- index
    // mappings
    map > m;
  
    int sum = 0;
  
    // Stores the prefix sum of
    // the original array
    int prefix_sum[n];
  
    for (int i = 0; i < n; i++) {
        sum += arr[i];
  
        // Check if we get sum negative
        // starting from first element
        if (sum < 0)
            return { 0, i };
  
        prefix_sum[i] = sum;
        m[sum].push_back(i);
    }
  
    // Iterate through array find
    // the sum which is just less
    // then the previous prefix sum
    for (int i = 1; i < n; i++) {
  
        // Check if the starting element
        // is itself negative
        if (arr[i] < 0)
  
            // arr[i] becomes the required
            // subarray
            return { i, i };
  
        else {
            int pre_sum = prefix_sum[i - 1];
  
            // Find the index which forms
            // negative sum subarray
            // from i-th index
            int index = b_search(pre_sum,
                                 m, i);
  
            // If a subarray is found
            // starting from i-th index
            if (index != -1)
                return { i, index };
        }
    }
  
    // Return -1 if no such
    // subarray is present
    return { -1 };
}
  
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, -1, 3, -4, 3, -5 };
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    vector res = findSubarray(arr, n);
  
    // If subarray does not exist
    if (res[0] == -1)
        cout << "-1" << endl;
  
    // If the subarray exists
    else {
        cout << res[0]
             << " " << res[1];
    }
    return 0;
}

输出：

0 6

时间复杂度： O(N * log N)
辅助空间： O(N)