Maximum Absolute Sum of Any Subarray

Maximum Absolute Sum of Any Subarray - Problem

You are given an integer array nums. The absolute sum of a subarray [nums_l, nums_l+1, ..., nums_r-1, nums_r] is abs(nums_l + nums_l+1 + ... + nums_r-1 + nums_r).

Return the maximum absolute sum of any (possibly empty) subarray of nums.

Note: abs(x) is defined as follows:

If x is a negative integer, then abs(x) = -x.
If x is a non-negative integer, then abs(x) = x.

Input & Output

Example 1 — Mixed Positive and Negative

$ Input: nums = [1,-3,2,1,-4]

› Output: 4

💡 Note: The subarray [2,1] has sum = 3, absolute sum = |3| = 3. The subarray [-4] has sum = -4, absolute sum = |-4| = 4. The maximum absolute sum is 4.

Example 2 — All Positive Numbers

$ Input: nums = [2,-5,1,-4,3,-1]

› Output: 8

💡 Note: The subarray [-5,1,-4] has sum = -8, absolute sum = |-8| = 8. This gives the maximum absolute sum.

Example 3 — Single Element

$ Input: nums = [-3]

› Output: 3

💡 Note: The only subarray is [-3] with sum = -3, absolute sum = |-3| = 3.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12

The key insight is that maximum absolute sum is either the maximum positive subarray sum or absolute value of minimum negative subarray sum. Best approach uses Kadane's algorithm to find both in linear time. Time: O(n), Space: O(1)

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n³) Space: O(1)

Generate every possible subarray, calculate its sum, take absolute value, and track the maximum. This involves nested loops to consider all starting and ending positions.

Modified Kadane's Algorithm

⏱️ Time: O(n) Space: O(1)

The maximum absolute sum is either the maximum positive subarray sum or the absolute value of the minimum negative subarray sum. We run Kadane's algorithm twice: once to find maximum sum and once to find minimum sum, then return the larger absolute value.

Optimized Brute Force

⏱️ Time: O(n²) Space: O(1)

Instead of recalculating each subarray sum from scratch, we extend the current subarray by one element at a time. This eliminates the innermost loop while still checking all subarrays.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct Queue {
    struct TreeNode** nodes;
    int front;
    int rear;
    int capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* queue = malloc(sizeof(struct Queue));
    queue->nodes = malloc(sizeof(struct TreeNode*) * capacity);
    queue->front = 0;
    queue->rear = -1;
    queue->capacity = capacity;
    return queue;
}

void enqueue(struct Queue* queue, struct TreeNode* node) {
    if (queue->rear < queue->capacity - 1) {
        queue->nodes[++queue->rear] = node;
    }
}

struct TreeNode* dequeue(struct Queue* queue) {
    if (queue->front <= queue->rear) {
        return queue->nodes[queue->front++];
    }
    return NULL;
}

int isEmpty(struct Queue* queue) {
    return queue->front > queue->rear;
}

int size(struct Queue* queue) {
    return queue->rear - queue->front + 1;
}

int maxLevelSum(struct TreeNode* root) {
    if (!root) return 1;
    
    struct Queue* queue = createQueue(10000);
    enqueue(queue, root);
    int level = 1;
    int maxSum = INT_MIN;
    int resultLevel = 1;
    
    while (!isEmpty(queue)) {
        int levelSize = size(queue);
        int levelSum = 0;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            levelSum += node->val;
            
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        if (levelSum > maxSum) {
            maxSum = levelSum;
            resultLevel = level;
        }
        
        level++;
    }
    
    free(queue->nodes);
    free(queue);
    return resultLevel;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTreeFromArray(char* input) {
    if (!input || strlen(input) <= 2) return NULL;
    
    char* str = malloc(strlen(input) + 1);
    strcpy(str, input);
    
    // Remove brackets
    char* start = strchr(str, '[');
    char* end = strchr(str, ']');
    if (!start || !end) {
        free(str);
        return NULL;
    }
    start++;
    *end = '\0';
    
    if (strlen(start) == 0) {
        free(str);
        return NULL;
    }
    
    struct TreeNode** nodes = malloc(10000 * sizeof(struct TreeNode*));
    int nodeCount = 0;
    
    char* token = strtok(start, ",");
    while (token) {
        while (*token == ' ') token++; // trim spaces
        if (strcmp(token, "null") == 0) {
            nodes[nodeCount++] = NULL;
        } else {
            int val = atoi(token);
            nodes[nodeCount++] = createNode(val);
        }
        token = strtok(NULL, ",");
    }
    
    if (nodeCount == 0 || !nodes[0]) {
        free(nodes);
        free(str);
        return NULL;
    }
    
    struct TreeNode* root = nodes[0];
    int parentIndex = 0;
    int childIndex = 1;
    
    while (childIndex < nodeCount) {
        // Find next non-null parent
        while (parentIndex < nodeCount && !nodes[parentIndex]) {
            parentIndex++;
        }
        
        if (parentIndex >= nodeCount) break;
        
        // Assign left child
        if (childIndex < nodeCount) {
            nodes[parentIndex]->left = nodes[childIndex];
            childIndex++;
        }
        
        // Assign right child
        if (childIndex < nodeCount) {
            nodes[parentIndex]->right = nodes[childIndex];
            childIndex++;
        }
        
        parentIndex++;
    }
    
    free(nodes);
    free(str);
    return root;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin)) {
        // Remove newline
        input[strcspn(input, "\n")] = 0;
        
        struct TreeNode* root = buildTreeFromArray(input);
        printf("%d\n", maxLevelSum(root));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen