Make a Positive Array

Make a Positive Array - Problem

You are given an array nums. An array is considered positive if the sum of all numbers in each subarray with more than two elements is positive.

You can perform the following operation any number of times: Replace one element in nums with any integer between -10¹⁸ and 10¹⁸.

Find the minimum number of operations needed to make nums positive.

Input & Output

Example 1 — Basic Negative Array

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

› Output: 1

💡 Note: Subarrays with length ≥ 3: [-5, 2, -3] has sum -6 ≤ 0, [2, -3, 1] has sum 0 ≤ 0, and [-5, 2, -3, 1] has sum -5 ≤ 0. Replace nums[1] = 2 with a large positive number. This makes [-5, X, -3] positive, [X, -3, 1] positive, and [-5, X, -3, 1] positive. So 1 operation is needed.

Example 2 — Already Positive

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

› Output: 0

💡 Note: The only subarray with length ≥ 3 is [1, 2, 3] with sum 6 > 0. Array is already positive, so 0 operations needed.

Example 3 — Multiple Problems

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

› Output: 2

💡 Note: Multiple negative subarrays exist. Replace the two most impactful negative elements (like nums[1] = -3 and nums[3] = -4) to make all subarrays positive with 2 operations.

Constraints

1 ≤ nums.length ≤ 1000
-10¹⁸ ≤ nums[i] ≤ 10¹⁸
You can replace any element with any integer between -10¹⁸ and 10¹⁸

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 25

The key insight is to identify which elements contribute to the most negative subarrays and replace them greedily. The greedy approach calculates impact scores and targets high-impact negative elements first. Time: O(n³), Space: O(n)

Common Approaches

✓ Brute Force - Check All Combinations

⏱️ Time: O(2ⁿ × n³) Space: O(n)

Generate all possible ways to replace elements and check if each results in a positive array. This involves checking every subarray of length 3+ after each replacement combination.

Greedy Replacement Strategy

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

Identify which elements contribute to the most negative subarrays and replace them with large positive values. Use a scoring system to prioritize replacements that fix the maximum number of problems.

Prefix Sum Analysis

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

Calculate prefix sums to quickly identify which subarrays have non-positive sums. Then use greedy approach to replace elements that contribute to the most negative subarrays.

Brute Force - Check All Combinations — Algorithm Steps

Generate all possible replacement combinations
For each combination, check if all subarrays length 3+ have positive sum
Return minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try replacing 0, 1, 2, ... elements

Check Each Combination

Verify all subarrays length 3+ are positive

Return Minimum

First valid combination gives minimum operations

Code -

solution.c — C

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

int isPositive(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 3; j <= n; j++) {
            long long sum = 0;
            for (int k = i; k < j; k++) {
                sum += arr[k];
            }
            if (sum <= 0) return 0;
        }
    }
    return 1;
}

int solution(int* nums, int n) {
    if (n <= 2) return 0;
    
    if (isPositive(nums, n)) return 0;
    
    // Try replacing 1 element
    for (int i = 0; i < n; i++) {
        int* temp = malloc(n * sizeof(int));
        memcpy(temp, nums, n * sizeof(int));
        temp[i] = 1000000000;
        if (isPositive(temp, n)) {
            free(temp);
            return 1;
        }
        free(temp);
    }
    
    // Try replacing 2 elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int* temp = malloc(n * sizeof(int));
            memcpy(temp, nums, n * sizeof(int));
            temp[i] = temp[j] = 1000000000;
            if (isPositive(temp, n)) {
                free(temp);
                return 2;
            }
            free(temp);
        }
    }
    
    // Try replacing 3 elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                int* temp = malloc(n * sizeof(int));
                memcpy(temp, nums, n * sizeof(int));
                temp[i] = temp[j] = temp[k] = 1000000000;
                if (isPositive(temp, n)) {
                    free(temp);
                    return 3;
                }
                free(temp);
            }
        }
    }
    
    return 3;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n³)

2^n combinations times n^3 to check all subarrays for each combination

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for temporary array modifications

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler