Maximum Product After K Increments

Maximum Product After K Increments - Problem

You are given an array of non-negative integers nums and an integer k. In one operation, you may choose any element from nums and increment it by 1.

Return the maximum product of nums after at most k operations. Since the answer may be very large, return it modulo 10⁹ + 7.

Note that you should maximize the product before taking the modulo.

Input & Output

Example 1 — Basic Case

$ Input: nums = [0,4], k = 5

› Output: 20

💡 Note: Increment the first element 5 times: [0,4] → [5,4]. Product = 5 × 4 = 20.

Example 2 — Multiple Small Elements

$ Input: nums = [6,3,3,2], k = 2

› Output: 216

💡 Note: Increment smallest elements: [6,3,3,2] → [6,3,3,3] → [6,3,4,3]. Product = 6 × 3 × 4 × 3 = 216.

Example 3 — Zero in Array

$ Input: nums = [1,0,1], k = 1

› Output: 1

💡 Note: Increment the zero: [1,0,1] → [1,1,1]. Product = 1 × 1 × 1 = 1.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 Apple 4

The key insight is to always increment the smallest elements first to maximize product growth. The best approach uses a min-heap to efficiently find and increment the smallest element k times. Time: O(n + k log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(n+k-1, k)) Space: O(k)

Generate all possible combinations of distributing k increments across array elements and calculate the product for each combination to find the maximum.

Frequency Count Optimization

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

Instead of incrementing individual elements, count frequency of each value and distribute increments smartly. Process values from smallest to largest, incrementing entire frequency groups at once.

Greedy with Priority Queue

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

Use a min-heap to efficiently find and increment the smallest element k times. This greedy approach maximizes product because incrementing smaller numbers has greater impact on the final product.

Brute Force - Try All Combinations — Algorithm Steps

Generate all ways to distribute k increments
Calculate product for each distribution
Return maximum product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all ways to distribute k increments

Calculate Products

Compute product for each distribution

Find Maximum

Return the largest product found

Code -

solution.c — C

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

const int MOD = 1000000007;

void heapifyUp(int* heap, int idx) {
    int parent = (idx - 1) / 2;
    if (parent >= 0 && heap[parent] > heap[idx]) {
        int temp = heap[parent];
        heap[parent] = heap[idx];
        heap[idx] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(int* heap, int size, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < size && heap[left] < heap[smallest]) {
        smallest = left;
    }
    if (right < size && heap[right] < heap[smallest]) {
        smallest = right;
    }
    
    if (smallest != idx) {
        int temp = heap[idx];
        heap[idx] = heap[smallest];
        heap[smallest] = temp;
        heapifyDown(heap, size, smallest);
    }
}

int solution(int* nums, int n, int k) {
    int* heap = (int*)malloc(n * sizeof(int));
    memcpy(heap, nums, n * sizeof(int));
    
    // Build min heap
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapifyDown(heap, n, i);
    }
    
    // Greedily increment smallest element k times
    for (int i = 0; i < k; i++) {
        heap[0]++;
        heapifyDown(heap, n, 0);
    }
    
    long long result = 1;
    for (int i = 0; i < n; i++) {
        result = (result * (long long)heap[i]) % MOD;
    }
    
    free(heap);
    return (int)result;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Remove brackets and parse
    char* start = strchr(line, '[');
    if (start) start++;
    char* end = strchr(line, ']');
    if (end) *end = '\0';
    
    int nums[100000];
    int n = 0;
    
    if (start && strlen(start) > 0) {
        char* token = strtok(start, ",");
        while (token != NULL) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n+k-1, k))

Need to try all ways to distribute k identical items into n distinct bins

⚡ Linearithmic

Space Complexity

O(k)

Recursion depth for generating combinations

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

425 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler