Maximum prefix-sum for a given range

Given an array arr[] of integers and a list of queries. Each query consists of two indices, leftIndex and rightIndex, defining a range in the array. For each query, calculate the maximum prefix sum within the given range.
Note: A prefix sum is the sum of all elements from the start of the range up to a certain point within the range.

Examples:

Input: arr[] = [ -1, 2, 3, -5 ]
leftIndex[] = [ 0, 1 ], rightIndex = [ 3, 3 ]
Output: 4 5
Explanation: For the range [0, 3], the prefix sums are [-1, 1, 4, -1]. The maximum is 4. For the range [1, 3], the prefix sums are [2, 5, 0]. The maximum is 5.
Input: arr = [1, -2, 3, 4, -5], leftIndex = [0, 2, 1], rightIndex = [4, 3, 3]
Output: 6 7 5
Explanation: For the range [0, 4], the prefix sums are [1, -1, 2, 6, 1]. The maximum is 6. For the range [2, 3], the prefix sums are [3, 7]. The maximum is 7. For the range [1, 3], the prefix sums are [-2, 1, 5]. The maximum is 5.

Try It Yourself

Table of Content

[Naive Approach] - Generating All Subarrays - O(q * n) Time and O(1) Space
[Expected Approach] - Using Segment Tree - O(q * log n) Time and O(n) Space

[Naive Approach] - Generating All Subarrays - O(q * n) Time and O(1) Space

The idea is to run a loop from l to r and calculate max prefix sum from l to r for every query.

C++

#include <bits/stdc++.h>
using namespace std;

// Function to return the maximum prefix sum for each query
vector<int> maxPrefixes(vector<int>& arr, 
    vector<int>& leftIndex, vector<int>& rightIndex) {
    int q = leftIndex.size();
    
    // to store the results
    vector<int> res;

    // process all the queries
    for(int i = 0; i < q; i++) {
        int l = leftIndex[i];
        int r = rightIndex[i];

        // to store the sum of prefix arrays
        int sum = 0;

        // to store the max sum
        int maxSum = INT_MIN;

        for (int i = l; i <= r; i++) {
            sum += arr[i];
            maxSum = max(maxSum, sum);
        }
        res.push_back(maxSum);
    }

    return res;
}

int main() {
    vector<int> arr = {1, -2, 3, 4, -5};
    vector<int> leftIndex = {0, 2, 1};
    vector<int> rightIndex = {4, 3, 3};
    vector<int> res = maxPrefixes(arr, leftIndex, rightIndex);
    for(int i = 0; i < res.size(); i++) {
        cout << res[i] << " ";
    }
    return 0;
}

Java

import java.util.*;

class GfG {

    // Function to return the maximum prefix sum for each query
    static List<Integer> maxPrefixes(List<Integer> arr, List<Integer> leftIndex, List<Integer> rightIndex) {
        int q = leftIndex.size();
        
        // to store the results
        List<Integer> res = new ArrayList<>();
        
        // process all the queries
        for (int i = 0; i < q; i++) {
            int l = leftIndex.get(i);
            int r = rightIndex.get(i);
            
            // to store the sum of prefix arrays
            int sum = 0;
            
            // to store the max sum
            int maxSum = Integer.MIN_VALUE;
            
            for (int j = l; j <= r; j++) {
                sum += arr.get(j);
                maxSum = Math.max(maxSum, sum);
            }
            res.add(maxSum);
        }
        
        return res;
    }
    
    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(1, -2, 3, 4, -5);
        List<Integer> leftIndex = Arrays.asList(0, 2, 1);
        List<Integer> rightIndex = Arrays.asList(4, 3, 3);
        List<Integer> res = maxPrefixes(arr, leftIndex, rightIndex);
        for (int i = 0; i < res.size(); i++) {
            System.out.print(res.get(i) + " ");
        }
    }
}

Python

# Function to return the maximum prefix sum for each query.
def maxPrefixes(arr, leftIndex, rightIndex):
    q = len(leftIndex)
    
    # to store the results
    res = []
    
    # process all the queries
    for i in range(q):
        l = leftIndex[i]
        r = rightIndex[i]
        
        # to store the sum of prefix arrays
        sum_val = 0
        
        # to store the max sum
        maxSum = -float('inf')
        
        for j in range(l, r + 1):
            sum_val += arr[j]
            maxSum = max(maxSum, sum_val)
        res.append(maxSum)
    
    return res

arr = [1, -2, 3, 4, -5]
leftIndex = [0, 2, 1]
rightIndex = [4, 3, 3]
res = maxPrefixes(arr, leftIndex, rightIndex)
print(" ".join(map(str, res)))

using System;
using System.Collections.Generic;

class GfG {

    // Function to return the maximum prefix sum for each query
    static List<int> maxPrefixes(List<int> arr, List<int> leftIndex, List<int> rightIndex) {
        int q = leftIndex.Count;
        
        // to store the results
        List<int> res = new List<int>();
        
        // process all the queries
        for (int i = 0; i < q; i++) {
            int l = leftIndex[i];
            int r = rightIndex[i];
            
            // to store the sum of prefix arrays
            int sum = 0;
            
            // to store the max sum
            int maxSum = int.MinValue;
            
            for (int j = l; j <= r; j++) {
                sum += arr[j];
                maxSum = Math.Max(maxSum, sum);
            }
            res.Add(maxSum);
        }
        
        return res;
    }

    public static void Main() {
        List<int> arr = new List<int> {1, -2, 3, 4, -5};
        List<int> leftIndex = new List<int> {0, 2, 1};
        List<int> rightIndex = new List<int> {4, 3, 3};
        List<int> res = maxPrefixes(arr, leftIndex, rightIndex);
        for (int i = 0; i < res.Count; i++) {
            Console.Write(res[i] + " ");
        }
    }
}

JavaScript

// Function to return the maximum prefix sum for each query.
function maxPrefixes(arr, leftIndex, rightIndex) {
    let q = leftIndex.length;
    
    // to store the results
    let res = [];
    
    // process all the queries
    for (let i = 0; i < q; i++) {
        let l = leftIndex[i];
        let r = rightIndex[i];
        
        // to store the sum of prefix arrays
        let sum = 0;
        
        // to store the max sum
        let maxSum = -Infinity;
        
        for (let j = l; j <= r; j++) {
            sum += arr[j];
            maxSum = Math.max(maxSum, sum);
        }
        res.push(maxSum);
    }
    
    return res;
}

let arr = [1, -2, 3, 4, -5];
let leftIndex = [0, 2, 1];
let rightIndex = [4, 3, 3];
let res = maxPrefixes(arr, leftIndex, rightIndex);
console.log(res.join(" "));

Output

6 7 5

[Expected Approach] - Using Segment Tree - O(q * log n) Time and O(n) Space

The idea is to use a segment tree to efficiently answer range queries for the maximum prefix sum. Each node in the segment tree stores both the total sum of its segment and the maximum prefix sum within that segment, so that when two segments are merged, the overall prefix sum can be computed as the maximum of the left segment’s prefix sum and the sum of the left segment plus the right segment’s prefix sum.

Segment Tree Structure:

The segment tree is structured as an array-based binary tree. The leaf nodes represent individual elements of the input array. Each internal node represents a merged segment where its stored sum is the total sum of the leaves in its segment and its prefix sum is computed as the maximum between the left child’s prefix sum and the left child’s sum plus the right child’s prefix sum. For a node at index i, its left child is at 2i+1, its right child at 2i+2, and its parent is at (i-1)/2.

Follow the below given steps:

Create a segment tree where each node stores two values: the sum of the segment and the maximum prefix sum for that segment.
For leaf nodes, initialize both values with the corresponding element from the input array.
For internal nodes, merge the two child nodes by setting the node’s sum as the sum of its children and its prefix sum as the maximum of the left child’s prefix sum and the sum of the left child plus the right child’s prefix sum.
To answer a query, perform a range query on the segment tree to retrieve the combined node for the specified range, and then return its stored maximum prefix sum as the answer.

C++

#include <bits/stdc++.h>
using namespace std;

// structure to store the segment tree
struct Node {
    int sum;
    int prefix;
    Node() {
        sum = 0;
        prefix = 0;
    }
};

// function to build the segment tree
void build(vector<int> &arr, int ind, 
    int start, int end, vector<Node> &tree) {

    // if there is only one element
    // store it in current node
    if (start == end) {        
        tree[ind].sum = arr[start];
        tree[ind].prefix = arr[start];
    } 
    else {
        int mid = (start + end) / 2;

        // If there are more than one elements,
        // then recur for left and right subtrees
        build(arr, 2 * ind + 1, start, mid, tree);
        build(arr, 2 * ind + 2, mid + 1, end, tree);

        // adds the sum and stores in the
        // mid position of segment tree
        tree[ind].sum = tree[2 * ind + 1].sum + 
                        tree[2 * ind + 2].sum;

        // stores the max of prefix-sum either
        // from right or from left.
        tree[ind].prefix = max(tree[2 * ind + 1].prefix, 
        tree[2 * ind + 1].sum + tree[2 * ind + 2].prefix);
    }
}

// function to do the range query in the 
// segment tree for the maximum prefix sum
Node query(int ind, int start, int end, 
    int l, int r, vector<Node> &tree) {

    // to store the result
    Node result;
    result.sum = result.prefix = -1;

    // If segment of this node is outside the given 
    // range, then return the minimum value.
    if (start > r || end < l)
        return result;

    // If segment of this node is a part of given
    // range, then return the node of the segment
    if (start >= l && end <= r)
        return tree[ind];

    int mid = (start + end) / 2;

    // if left segment of this node falls out of
    // range, then recur in the right side of the tree
    if (l > mid)
        return query(2 * ind + 2, mid + 1, end, l, r, tree);

    // if right segment of this node falls out of
    // range, then recur in the left side of the tree
    if (r <= mid)
        return query(2 * ind + 1, start, mid, l, r, tree);

    // If a part of this segment overlaps 
    // with the given range
    Node left = query(2 * ind + 1, start, mid, l, r, tree);
    Node right = query(2 * ind + 2, mid + 1, end, l, r, tree);

    // adds the sum of the left and right segment
    result.sum = left.sum + right.sum;

    // stores the max of prefix-sum
    result.prefix = max(left.prefix, left.sum + right.prefix);

    // returns the value
    return result;
}

// Function to return the maximum prefix sum for each query
vector<int> maxPrefixes(vector<int>& arr, 
    vector<int>& leftIndex, vector<int>& rightIndex) {
    int n = arr.size();

    // to store the segment tree
    vector<Node> tree(4 * n);

    // build the segment tree
    build(arr, 0, 0, n - 1, tree);

    int q = leftIndex.size();

    // to store the results
    vector<int> res;

    for(int i = 0; i < q; i++) {
        int l = leftIndex[i];
        int r = rightIndex[i];

        // query the segment tree
        Node result = query(0, 0, n - 1, l, r, tree);

        // store the result
        res.push_back(result.prefix);
    }

    return res;
}

int main() {
    vector<int> arr = {1, -2, 3, 4, -5};
    vector<int> leftIndex = {0, 2, 1};
    vector<int> rightIndex = {4, 3, 3};
    vector<int> res = maxPrefixes(arr, leftIndex, rightIndex);
    for(int i = 0; i < res.size(); i++) {
        cout << res[i] << " ";
    }
    return 0;
}