Minimum Increments for Target Multiples in an Array

Minimum Increments for Target Multiples in an Array - Problem

Array Math Dynamic Programming Bit Manipulation Number Theory Bitmask Hard

You're given two arrays: nums and target. Your mission is to make sure that every element in the target array has at least one multiple present in the nums array.

In each operation, you can increment any element in nums by 1. The challenge is to find the minimum number of operations needed to achieve this goal.

Example: If target = [2, 3] and nums = [1, 4], you need to increment 1 to 2 (1 operation) to get a multiple of 2, and increment 4 to 6 (2 operations) to get a multiple of 3. Total: 3 operations.

This problem combines number theory with optimization - you need to smartly assign elements from nums to target elements to minimize the total cost.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can increment nums[0] from 1 to 2 (0 operations since 1→2 via nums[1]=4→4 covers target[0]=2), and increment nums[1] from 4 to 6 (2 operations) to get a multiple of 3. Total minimum: 2 operations.

example_2.py — Multiple Options

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

› Output: 0

💡 Note: nums already contains 4 which is a multiple of 2, and 6 which is a multiple of 6. No operations needed.

example_3.py — Edge Case with Zero

$ Input: nums = [0, 5], target = [1, 0]

› Output: 1

💡 Note: For target[0]=1, we need nums[0]=0→1 (1 operation). For target[1]=0, nums[0]=0 already covers it (0 operations). Total: 1 operation.

Visualization

Tap to expand

Understanding the Visualization

Calculate Costs

For each arrow-target pair, calculate the minimum increments needed for the arrow to hit the target (reach a multiple)

State Exploration

Use bitmask DP to track which targets are covered and explore all possible assignments

Optimal Assignment

Find the assignment that covers all targets with minimum total cost

Key Takeaway

🎯 Key Insight: This is a minimum cost assignment problem where we need to cover all targets with minimum total increments. Bitmask DP efficiently explores all possible coverage combinations to find the optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^m × m)

n elements × 2^m possible masks × m targets to check for each transition

✓ Linear Growth

Space Complexity

O(2^m)

DP array of size 2^m to store minimum cost for each mask

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10
1 ≤ target.length ≤ 10
0 ≤ nums[i], target[i] ≤ 10⁴
Each target element must have at least one multiple in nums after operations

Asked in

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

This problem requires finding the minimum cost assignment where each target element is covered by at least one multiple from the nums array. The optimal approach uses bitmask dynamic programming to explore all possible coverage states efficiently, achieving O(n × 2^m × m) time complexity. For smaller inputs, a greedy approach can work by independently finding the minimum cost to cover each target.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask	O(n × 2^m × m)	O(2^m)	Use bitmask DP to track covered targets and find optimal assignment
Greedy Assignment with Sorting	O(n × m × log(n × m))	O(n × m)	Sort both arrays and use greedy assignment for optimal solution
Brute Force (Try All Assignments)	O(2^(n+m) × n × m)	O(n × m)	Try every possible way to assign nums elements to target elements

Dynamic Programming with Bitmask — Algorithm Steps

Calculate cost matrix: cost[i][j] = operations to make nums[i] a multiple of target[j]
Use bitmask to represent which targets are covered
DP state: dp[mask] = minimum cost to cover targets represented by mask
For each state, try adding each nums element to cover remaining targets
Return dp[(1<<m)-1] where m is length of target array

Visualization

Tap to expand

Step-by-Step Walkthrough

Cost Matrix

Calculate cost for each nums[i] to cover target[j]

DP States

Each bitmask represents which targets are covered

State Transitions

For each state, try covering remaining targets

Code -

solution.c — C

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

int minimumOperations(int* nums, int numsSize, int* target, int targetSize) {
    int n = numsSize, m = targetSize;
    
    // Calculate cost matrix
    int cost[n][m];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (target[j] == 0) {
                cost[i][j] = nums[i] == 0 ? 0 : INT_MAX;
            } else {
                int multiple = ((nums[i] + target[j] - 1) / target[j]) * target[j];
                cost[i][j] = multiple - nums[i];
            }
        }
    }
    
    // DP with bitmask
    int dpSize = 1 << m;
    int* dp = (int*)malloc(dpSize * sizeof(int));
    for (int i = 0; i < dpSize; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int mask = 0; mask < dpSize; mask++) {
        if (dp[mask] == INT_MAX) continue;
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!(mask & (1 << j))) {
                    int newMask = mask | (1 << j);
                    if (dp[mask] + cost[i][j] < dp[newMask]) {
                        dp[newMask] = dp[mask] + cost[i][j];
                    }
                }
            }
        }
    }
    
    int result = dp[dpSize - 1];
    free(dp);
    return result;
}

int main() {
    int nums[] = {1, 4};
    int target[] = {2, 3};
    printf("%d\n", minimumOperations(nums, 2, target, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^m × m)

n elements × 2^m possible masks × m targets to check for each transition

✓ Linear Growth

Space Complexity

O(2^m)

DP array of size 2^m to store minimum cost for each mask

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10
1 ≤ target.length ≤ 10
0 ≤ nums[i], target[i] ≤ 10⁴
Each target element must have at least one multiple in nums after operations

43.2K Views

Medium-High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmask — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler