📌  相关文章
📜  给定数组的第一个子数组的总和为负

📅  最后修改于: 2021-04-26 09:42:43             🧑  作者: Mango

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

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

例子:

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

时间复杂度: O(N 2 )
辅助空间: 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)