Minimize the Difference Between Target and Chosen Elements

Minimize the Difference Between Target and Chosen Elements - Problem

You are given an m x n integer matrix mat and an integer target.

Choose one integer from each row in the matrix such that the absolute difference between target and the sum of the chosen elements is minimized.

Return the minimum absolute difference.

The absolute difference between two numbers a and b is |a - b|.

Input & Output

Example 1 — Perfect Match

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

› Output: 0

💡 Note: Choose 1 from first row and 6 from second row: 1 + 6 = 7, which exactly equals target. Difference is |7 - 7| = 0. Other combinations like 2 + 5 = 7 and 3 + 4 = 7 also give difference 0.

Example 2 — Exact Target

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

› Output: 0

💡 Note: Choose 1 from first row and 3 from second row: 1 + 3 = 4, which exactly equals target. Difference is |4 - 4| = 0.

Example 3 — Single Row

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

› Output: 1

💡 Note: With only one row, we must choose one element. The closest to 6 is 7, giving difference |6 - 7| = 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use dynamic programming to track all possible sums we can achieve by selecting one element from each row. The optimal approach uses a set to store possible sums and iteratively expands it for each row. Time: O(m × n × S), Space: O(S) where S is the number of unique sums.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n^m) Space: O(m)

For each row, try every element and recursively explore all combinations. Calculate the sum for each complete combination and find the one with minimum difference from target.

Dynamic Programming - Track Possible Sums

⏱️ Time: O(m × n × S) Space: O(S)

For each row, maintain a set of all possible sums we can achieve. For each element in the current row, generate new sums by adding it to all previous sums. Finally, find the sum closest to target.

Memoization - Cache Intermediate Results

⏱️ Time: O(m × S) Space: O(m × S)

Similar to brute force but cache results of (row, currentSum) pairs to avoid redundant calculations. This reduces the search space significantly.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible combinations recursively
Calculate sum for each combination
Find minimum absolute difference from target

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with row 0, sum = 0

Branch

Try each element in current row

Result

Find minimum difference among all paths

Code -

solution.c — C

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

int backtrack(int** mat, int* colSizes, int rows, int target, int row, int currentSum) {
    if (row == rows) {
        int diff = target - currentSum;
        return diff < 0 ? -diff : diff;
    }
    
    int minDiff = INT_MAX;
    for (int i = 0; i < colSizes[row]; i++) {
        int diff = backtrack(mat, colSizes, rows, target, row + 1, currentSum + mat[row][i]);
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    
    return minDiff;
}

int solution(int** mat, int* colSizes, int rows, int target) {
    return backtrack(mat, colSizes, rows, target, 0, 0);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    int** mat = malloc(10 * sizeof(int*));
    int* colSizes = malloc(10 * sizeof(int));
    int rows = 0;
    
    // Parse [[1,2],[3,4]] format
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            mat[rows] = malloc(10 * sizeof(int));
            int cols = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                    mat[rows][cols++] = atoi(ptr);
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                } else {
                    ptr++;
                }
            }
            colSizes[rows] = cols;
            rows++;
        }
        ptr++;
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(mat, colSizes, rows, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^m)

For m rows with n elements each, we try n choices for each row

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth equals number of rows

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

892 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