Maximum Product After K Increments - Practice Coding Problems

Maximum Product After K Increments - Problem

You're an investment manager with a portfolio of non-negative integer assets and exactly k investment opportunities. Each opportunity allows you to increase any single asset's value by 1.

Your goal is to maximize the total product of all asset values after making at most k investments. Since the final product could be astronomically large, return it modulo 10⁹ + 7.

Key insight: To maximize a product, you should always invest in the smallest current asset first, as this gives the highest relative return on investment.

Example: With assets [0, 4] and k = 5 investments:
• Invest 1 in asset 0: [1, 4] (product = 4)
• Invest 1 in asset 0: [2, 4] (product = 8)
• Invest 1 in asset 0: [3, 4] (product = 12)
• Invest 1 in asset 0: [4, 4] (product = 16)
• Invest 1 in either: [5, 4] or [4, 5] (product = 20)

Input & Output

example_1.py — Basic Case

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

› Output: 20

💡 Note: Start with [0,4]. Increment 0 five times: [1,4]→[2,4]→[3,4]→[4,4]→[5,4]. Final product: 5×4 = 20.

example_2.py — Equal Elements

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

› Output: 216

💡 Note: Start with [6,3,3,2]. Increment smallest (2): [6,3,3,3]. Increment any of the 3s: [6,3,4,3]. Product: 6×3×4×3 = 216.

example_3.py — Single Element

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

› Output: 49

💡 Note: Start with [1]. After 1000000 increments: [1000001]. Since 1000001 mod (10^9+7) = 1000001, but we need the actual modular arithmetic result which is 49.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10⁵
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Portfolio Analysis

Identify the weakest performing asset (minimum value)

Strategic Investment

Invest in the weakest asset to maximize relative improvement

Rebalance

Re-evaluate portfolio to find the new weakest asset

Repeat Process

Continue until all investment capital (k operations) is used

Key Takeaway

🎯 Key Insight: Greedy works because improving the smallest number always provides the maximum multiplicative benefit to the overall product.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach with a min-heap. Always increment the smallest element in the array, as this maximizes the multiplicative benefit. Time complexity: O(k log n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Distributions)	O(n^k)	O(k)	Try every possible way to distribute k increments among array elements
Min-Heap Greedy (Optimal)	O(k log n)	O(n)	Use a min-heap to always increment the smallest element efficiently

Brute Force (Try All Distributions) — Algorithm Steps

Use recursion to try adding each increment to each possible array element
For each recursive call, try incrementing each element and recurse with k-1
Base case: when k=0, calculate and return the product of current array
Return the maximum product found across all distributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array and k operations remaining

Branch Creation

For each element, create a branch representing incrementing that element

Recursive Exploration

Recursively explore each branch with k-1 operations remaining

Base Case

When k=0, calculate product and return

Code -

solution.c — C

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

const int MOD = 1000000007;

int backtrack(int* arr, int n, int remaining) {
    if (remaining == 0) {
        long long product = 1;
        for (int i = 0; i < n; i++) {
            product = (product * arr[i]) % MOD;
        }
        return (int)product;
    }
    
    int maxProduct = 0;
    for (int i = 0; i < n; i++) {
        arr[i]++;
        int result = backtrack(arr, n, remaining - 1);
        if (result > maxProduct) {
            maxProduct = result;
        }
        arr[i]--; // backtrack
    }
    
    return maxProduct;
}

int maximumProductAfterKIncrements(int* nums, int n, int k) {
    return backtrack(nums, n, k);
}

int main() {
    int nums[] = {0, 4};
    int n = 2, k = 5;
    printf("%d\n", maximumProductAfterKIncrements(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each of k operations, we have n choices, leading to n^k total combinations

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is k, each call uses O(1) space

✓ Linear Space

42.4K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 Distributions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler