Minimum Time to Make Array Sum At Most x - Practice Coding Problems

Minimum Time to Make Array Sum At Most x - Problem

Imagine you have two arrays that represent a dynamic system where values grow over time, but you can strategically reset elements to minimize the total sum.

You're given two 0-indexed integer arrays nums1 and nums2 of equal length. Every second, the system evolves:

For all indices 0 ≤ i < nums1.length, nums1[i] increases by nums2[i]
After this growth, you can choose exactly one index and reset nums1[i] = 0

Your goal is to find the minimum time needed to make the sum of all elements in nums1 less than or equal to x. If it's impossible, return -1.

Example: If nums1 = [1, 2, 3], nums2 = [1, 2, 3], and x = 4, you need to strategically reset elements as they grow to keep the total sum ≤ 4.

Input & Output

example_1.py — Basic case

$ Input: nums1 = [1,2,3], nums2 = [1,2,3], x = 4

› Output: 3

💡 Note: At each second, we grow all elements and can reset one. To keep sum ≤ 4, we need to strategically reset elements with highest growth rates first, taking 3 seconds total.

example_2.py — Already satisfied

$ Input: nums1 = [1,2,3], nums2 = [3,3,3], x = 10

› Output: 0

💡 Note: Initial sum is 6, which is already ≤ 10, so no time needed.

example_3.py — Impossible case

$ Input: nums1 = [4,4,4], nums2 = [0,0,0], x = 4

› Output: -1

💡 Note: No growth occurs, but initial sum (12) > x (4), so it's impossible to achieve the target.

Constraints

1 ≤ nums1.length ≤ 10³
0 ≤ nums1[i], nums2[i] ≤ 10⁶
1 ≤ x ≤ 10¹⁴
nums1.length == nums2.length

Visualization

Tap to expand

Understanding the Visualization

Initial State

Arrays start with given values, growth rates determine increase per second

Growth Phase

All elements increase by their respective growth rates

Reset Phase

Choose one element to reset to 0 - prioritize high growth elements

Repeat Until Goal

Continue until total sum ≤ x

Key Takeaway

🎯 Key Insight: Sort by growth rate and use DP to find optimal reset timing - prioritize resetting high-growth elements early to minimize total accumulation

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses binary search on time combined with dynamic programming. Key insights: sort elements by growth rate in descending order, then use DP to find the minimum sum achievable with a given number of reset operations. The DP state dp[i][j] represents the minimum sum using the first i elements with j reset operations.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Dynamic Programming	O(n³ log n)	O(n²)	Binary search on time, use DP with sorted pairs to check feasibility
Brute Force (Try All Sequences)	O(n^t * t)	O(t)	Try all possible sequences of resetting elements and simulate the process

Binary Search + Dynamic Programming — Algorithm Steps

Create pairs of (nums1[i], nums2[i]) and sort by nums2[i] descending
Binary search on time t from 0 to n
For each t, use DP: dp[i][j] = min sum using first i elements with j operations
Check if any dp[n][k] ≤ x for k ∈ [0, t]

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Growth Rate

Sort pairs by nums2[i] in descending order

Binary Search Time

Binary search on possible time values

DP Check

Use DP to check if target achievable in given time

Optimize Search

Narrow search range based on DP result

Code -

solution.c — C

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

struct Pair {
    int val;
    int growth;
};

int compare(const void *a, const void *b) {
    struct Pair *pa = (struct Pair *)a;
    struct Pair *pb = (struct Pair *)b;
    return pb->growth - pa->growth; // Descending order
}

bool canAchieve(int* nums1, int* nums2, int n, int x, int t) {
    // Create pairs and sort
    struct Pair* pairs = (struct Pair*)malloc(n * sizeof(struct Pair));
    for (int i = 0; i < n; i++) {
        pairs[i].val = nums1[i];
        pairs[i].growth = nums2[i];
    }
    qsort(pairs, n, sizeof(struct Pair), compare);
    
    // DP: dp[i][j] = minimum sum using first i elements with j resets
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)malloc((t + 1) * sizeof(long long));
        for (int j = 0; j <= t; j++) {
            dp[i][j] = LLONG_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        long long val = pairs[i - 1].val;
        long long growth = pairs[i - 1].growth;
        long long contribution = val + growth * t;
        
        for (int j = 0; j <= t; j++) {
            // Option 1: Don't reset this element
            if (dp[i-1][j] != LLONG_MAX && dp[i-1][j] + contribution < dp[i][j]) {
                dp[i][j] = dp[i-1][j] + contribution;
            }
            
            // Option 2: Reset this element at some time k
            if (j > 0) {
                for (int k = 1; k <= t; k++) {
                    long long resetContribution = val + growth * (t - k);
                    if (dp[i-1][j-1] != LLONG_MAX && dp[i-1][j-1] + resetContribution < dp[i][j]) {
                        dp[i][j] = dp[i-1][j-1] + resetContribution;
                    }
                }
            }
        }
    }
    
    // Check if any configuration works
    bool result = false;
    for (int j = 0; j <= t; j++) {
        if (dp[n][j] <= x) {
            result = true;
            break;
        }
    }
    
    // Cleanup
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    free(pairs);
    
    return result;
}

int minimumTimeToMakeArraySumAtMostX(int* nums1, int* nums2, int n, int x) {
    int left = 0, right = n;
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieve(nums1, nums2, n, x, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ log n)

O(log n) for binary search, O(n²) for DP, O(n log n) for sorting

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n × (t+1)

⚠ Quadratic Space

26.0K Views

Medium Frequency

~35 min Avg. Time

847 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

Binary Search + Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler