Minimize the Difference Between Target and Chosen Elements

Minimize the Difference Between Target and Chosen Elements - Problem

You are given an m × n integer matrix and an integer target. Your mission is to select exactly one integer from each row to create a subset whose sum is as close as possible to the target value.

Goal: Minimize the absolute difference between the target and the sum of your chosen elements.

Input: A 2D matrix mat and an integer target

Output: The minimum possible absolute difference

Example: Given matrix [[1,2,3],[4,5,6],[7,8,9]] and target 13, you could choose [1,5,7] with sum 13, giving difference |13-13| = 0.

Input & Output

example_1.py — Basic Case

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]], target = 13

› Output: 0

💡 Note: We can choose [1,5,7] with sum 13, giving difference |13-13| = 0. This is optimal since we can achieve the exact target.

example_2.py — Impossible Exact Match

$ Input: mat = [[1],[2],[3]], target = 100

› Output: 94

💡 Note: We must choose [1,2,3] giving sum 6. The difference is |6-100| = 94. No other combination is possible.

example_3.py — Multiple Options

$ Input: mat = [[1,2,9,8,7]], target = 6

› Output: 1

💡 Note: With only one row, we can choose any single element. Element 7 gives difference |7-6| = 1, which is closest to target 6.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 70
1 ≤ mat[i][j] ≤ 70
1 ≤ target ≤ 800

Visualization

Tap to expand

Understanding the Visualization

Store 1: Electronics

Choose from $1, $2, or $3 items. All are possible starting points.

Store 2: Clothing

Add $4, $5, or $6 to each previous total. Now we can spend $5-$9.

Store 3: Books

Add $7, $8, or $9 to each total. Final possible totals: $12-$18.

Find Best Match

Target is $13. Closest achievable total is $12, difference = $1.

Key Takeaway

🎯 Key Insight: Dynamic Programming transforms an exponential search into efficient sum tracking. We build possible sums incrementally rather than exploring all combinations, achieving polynomial time complexity.

Asked in

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

The optimal approach uses Dynamic Programming to build all possible sums row by row. Instead of trying all k^m combinations, we maintain a set of achievable sums and update it for each row. This reduces time complexity from exponential to O(m × n × sum_range), making it practical for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m × n × sum_range)	O(sum_range)	Build all possible sums row by row using dynamic programming

Dynamic Programming (Optimal) — Algorithm Steps

Start with a set containing only 0 (no elements chosen yet)
For each row, create a new set of possible sums
For each element in current row, add it to each sum in previous set
Update our set of possible sums with the new sums
After processing all rows, find the sum closest to target
Return the minimum absolute difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with possible sums = {0}

Process Row 1

Add each element to all current sums

Process Row 2

Combine new elements with all previous sums

Find Minimum

Find sum closest to target

Code -

solution.c — C

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

int minimizeTheDifference(int** mat, int* colSizes, int rows, int target) {
    // Using array to simulate set (assuming reasonable sum range)
    int maxSum = 5000; // Adjust based on constraints
    int* possibleSums = calloc(maxSum + 1, sizeof(int));
    int* newSums = calloc(maxSum + 1, sizeof(int));
    
    possibleSums[0] = 1;
    
    for (int i = 0; i < rows; i++) {
        // Clear new sums
        for (int j = 0; j <= maxSum; j++) newSums[j] = 0;
        
        for (int j = 0; j < colSizes[i]; j++) {
            int num = mat[i][j];
            for (int prevSum = 0; prevSum <= maxSum; prevSum++) {
                if (possibleSums[prevSum] && prevSum + num <= maxSum) {
                    newSums[prevSum + num] = 1;
                }
            }
        }
        
        // Swap arrays
        int* temp = possibleSums;
        possibleSums = newSums;
        newSums = temp;
    }
    
    int minDiff = INT_MAX;
    for (int i = 0; i <= maxSum; i++) {
        if (possibleSums[i]) {
            int diff = abs(i - target);
            if (diff < minDiff) {
                minDiff = diff;
            }
        }
    }
    
    free(possibleSums);
    free(newSums);
    return minDiff;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m × n × sum_range)

Where m is rows, n is columns, and sum_range is the range of possible sums. We process each element and each possible sum.

✓ Linear Growth

Space Complexity

O(sum_range)

We store a set of all possible sums, which can be at most the total sum range

⚡ Linearithmic Space

43.6K Views

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler