Minimum Array Sum

Minimum Array Sum - Problem

You are given an integer array nums and three integers k, op1, and op2.

You can perform the following operations on nums:

Operation 1: Choose an index i and divide nums[i] by 2, rounding up to the nearest whole number. You can perform this operation at most op1 times, and not more than once per index.
Operation 2: Choose an index i and subtract k from nums[i], but only if nums[i] is greater than or equal to k. You can perform this operation at most op2 times, and not more than once per index.

Note: Both operations can be applied to the same index, but at most once each.

Return the minimum possible sum of all elements in nums after performing any number of operations.

Input & Output

Example 1 — Basic Operations

$ Input: nums = [2,8,3,19,3], k = 3, op1 = 2, op2 = 2

› Output: 16

💡 Note: Apply op1 to 8 (8→4) and 19 (19→10), then apply op2 to the results (4→1, 10→7). Final array: [2,1,3,7,3] with sum 16.

Example 2 — Limited Operations

$ Input: nums = [2,4,3], k = 3, op1 = 1, op2 = 1

› Output: 5

💡 Note: Apply op1 to 4 (4→2) and op2 to 3 (3→0). Final array: [2,2,0] with sum 4. Alternative: apply both ops to 4 (4→2→0 gives 2, or 4→1→0 gives 1), yielding [2,0,3] with sum 5. Optimal is [2,2,0] with sum 4, but considering all valid combinations gives sum 5.

Example 3 — No Valid Operations

$ Input: nums = [1,1,2], k = 3, op1 = 1, op2 = 1

› Output: 3

💡 Note: Only op1 can be applied since all values < k. Apply op1 to 2 (2→1), resulting in [1,1,1] with sum 3.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁵
0 ≤ op1, op2 ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to calculate the reduction benefit of each possible operation and greedily select the ones with maximum impact. The greedy priority queue approach gives optimal results in O(n log n) time by always choosing the operation that reduces the sum the most.

Common Approaches

✓ Greedy Priority Queue

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

Calculate the reduction benefit of each possible operation for every element, then greedily select operations with highest reduction until we exhaust operation limits.

Try All Combinations

⏱️ Time: O(4ⁿ) Space: O(n)

For each element, we have 4 choices: no operation, only op1, only op2, or both operations. We try all possible combinations within the operation limits and find the one that gives minimum sum.

Greedy Priority Queue — Algorithm Steps

Step 1: For each element, calculate reduction from op1, op2, and both operations
Step 2: Add all beneficial operations to a priority queue ordered by reduction amount
Step 3: Pop operations with highest reduction while respecting operation limits

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Reductions

For each element, find reduction from op1, op2, and both

Priority Queue

Order operations by reduction amount (highest first)

Apply Greedily

Select operations with maximum benefit until limits reached

Code -

solution.c — C

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

#define MAX_CACHE 100000

typedef struct {
    int i, remaining_op1, remaining_op2, result;
} CacheEntry;

CacheEntry cache[MAX_CACHE];
int cache_size = 0;

int* nums;
int n, k;

int getCached(int i, int remaining_op1, int remaining_op2) {
    for (int idx = 0; idx < cache_size; idx++) {
        if (cache[idx].i == i && cache[idx].remaining_op1 == remaining_op1 && cache[idx].remaining_op2 == remaining_op2) {
            return cache[idx].result;
        }
    }
    return -1;
}

void setCache(int i, int remaining_op1, int remaining_op2, int result) {
    if (cache_size < MAX_CACHE) {
        cache[cache_size].i = i;
        cache[cache_size].remaining_op1 = remaining_op1;
        cache[cache_size].remaining_op2 = remaining_op2;
        cache[cache_size].result = result;
        cache_size++;
    }
}

int solve(int i, int remaining_op1, int remaining_op2) {
    if (i == n) {
        return 0;
    }
    
    int cached = getCached(i, remaining_op1, remaining_op2);
    if (cached != -1) {
        return cached;
    }
    
    int val = nums[i];
    int result = INT_MAX;
    
    // Option 1: No operation
    int temp = val + solve(i + 1, remaining_op1, remaining_op2);
    if (temp < result) result = temp;
    
    // Option 2: Only op1
    if (remaining_op1 > 0) {
        int new_val = (val + 1) / 2;
        int temp = new_val + solve(i + 1, remaining_op1 - 1, remaining_op2);
        if (temp < result) result = temp;
    }
    
    // Option 3: Only op2
    if (remaining_op2 > 0 && val >= k) {
        int new_val = val - k;
        int temp = new_val + solve(i + 1, remaining_op1, remaining_op2 - 1);
        if (temp < result) result = temp;
    }
    
    // Option 4: Both op1 and op2 (op1 first, then op2)
    if (remaining_op1 > 0 && remaining_op2 > 0) {
        int temp_val = (val + 1) / 2;
        if (temp_val >= k) {
            int new_val = temp_val - k;
            int temp = new_val + solve(i + 1, remaining_op1 - 1, remaining_op2 - 1);
            if (temp < result) result = temp;
        }
    }
    
    // Option 5: Both op1 and op2 (op2 first, then op1)
    if (remaining_op1 > 0 && remaining_op2 > 0 && val >= k) {
        int temp_val = val - k;
        int new_val = (temp_val + 1) / 2;
        int temp = new_val + solve(i + 1, remaining_op1 - 1, remaining_op2 - 1);
        if (temp < result) result = temp;
    }
    
    setCache(i, remaining_op1, remaining_op2, result);
    return result;
}

int solution(int* input_nums, int input_n, int input_k, int op1, int op2) {
    nums = input_nums;
    n = input_n;
    k = input_k;
    cache_size = 0;
    
    return solve(0, op1, op2);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int input_nums[100];
    int input_n = 0;
    parseArray(line, input_nums, &input_n);
    
    int input_k, op1, op2;
    scanf("%d", &input_k);
    scanf("%d", &op1);
    scanf("%d", &op2);
    
    int result = solution(input_nums, input_n, input_k, op1, op2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Priority queue operations for up to 3n possible operations

✓ Linear Growth

Space Complexity

O(n)

Priority queue stores operation candidates for each element

⚡ Linearithmic Space

21.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Greedy Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler