Minimum Operations to Form Subsequence With Target Sum

Minimum Operations to Form Subsequence With Target Sum - Problem

Minimum Operations to Form Subsequence With Target Sum

You're given an array nums containing only powers of 2 (like 1, 2, 4, 8, 16...) and need to find the minimum number of operations to create a subsequence that sums to a target value.

The Operation: You can split any element nums[i] (where nums[i] > 1) into two smaller pieces of nums[i] / 2 each. For example, splitting 8 gives you two 4's.

Goal: Return the minimum operations needed so that you can select some elements from the array (a subsequence) that sum exactly to target. If impossible, return -1.

Example: If nums = [1, 2, 8] and target = 7, you could split 8 into two 4's, then split one 4 into two 2's, giving you [1, 2, 4, 2, 2]. Now you can pick [1, 2, 4] to sum to 7.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 8], target = 7

› Output: 1

💡 Note: We need to make 7. We have 1+2=3, but need 4 more. We can split 8 into two 4s (1 operation), then use 1+2+4=7.

example_2.py — Multiple Operations

$ Input: nums = [1, 32], target = 12

› Output: 2

💡 Note: Target 12 = 8+4. Split 32→16,16 (1 op), then split 16→8,8 (2 ops total). Now we have [1,8,8,16] and can use 8+4=12, but we need 4, so split another 8→4,4 (3 ops total). Actually optimal is 2: split 32→16,16, then 16→8,8, use 8+4 where 4 comes from splitting 8→4,4.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Sum of nums is 5, which is less than target 6. No amount of splitting can increase the total sum, so it's impossible.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2³⁰
nums[i] is a power of 2
1 ≤ target ≤ 2³¹ - 1

Visualization

Tap to expand

Understanding the Visualization

Count Your Bills

First, count how many bills of each denomination you have

Process Target Bits

Look at each bit of the target amount from right to left

Make Change Greedily

For each bit, either use available bills or break larger ones

Count Operations

Each bill break costs one operation

Key Takeaway

🎯 Key Insight: Greedy works for powers of 2 because any larger denomination can always be broken into exactly what we need for smaller bits, without affecting the optimality of future decisions.

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses a greedy approach with bit manipulation. Since all numbers are powers of 2, we can count available denominations and process the target's binary representation bit by bit. For each required bit, we either use available numbers of that denomination or split larger ones. Time complexity: O(n + log target), making it highly efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * 2^sum)	O(2^n)	Generate all possible arrays after operations and check if target is achievable
Greedy with Bit Counting (Optimal)	O(n + log target)	O(log target)	Count available powers of 2 and greedily use largest denominations first

Brute Force (Try All Combinations) — Algorithm Steps

For each number > 1 in the array, try splitting it
Recursively explore all possible split combinations
For each resulting array, check if target sum is possible using subset sum
Keep track of minimum operations across all valid paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [1, 2, 8], target = 7

Try Splits

Split 8 → [1, 2, 4, 4], split 2 → [1, 1, 1, 8], etc.

Check Feasibility

For each resulting array, check if target sum is possible

Track Minimum

Keep track of minimum operations across all valid paths

Code -

solution.c — C

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

bool canMakeTarget(int* arr, int size, int target) {
    bool* dp = calloc(target + 1, sizeof(bool));
    dp[0] = true;
    
    for (int i = 0; i < size; i++) {
        for (int j = target; j >= arr[i]; j--) {
            dp[j] = dp[j] || dp[j - arr[i]];
        }
    }
    
    bool result = dp[target];
    free(dp);
    return result;
}

int solve(int* arr, int size, int ops, int target) {
    if (canMakeTarget(arr, size, target)) {
        return ops;
    }
    
    int minOps = INT_MAX;
    for (int i = 0; i < size; i++) {
        if (arr[i] > 1) {
            int* newArr = malloc((size + 1) * sizeof(int));
            int newSize = 0;
            
            // Copy elements except arr[i]
            for (int j = 0; j < size; j++) {
                if (j != i) {
                    newArr[newSize++] = arr[j];
                }
            }
            
            // Add two halves
            newArr[newSize++] = arr[i] / 2;
            newArr[newSize++] = arr[i] / 2;
            
            int result = solve(newArr, newSize, ops + 1, target);
            if (result < minOps) {
                minOps = result;
            }
            
            free(newArr);
        }
    }
    
    return minOps == INT_MAX ? -1 : minOps;
}

int minOperations(int* nums, int numsSize, int target) {
    return solve(nums, numsSize, 0, target);
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * 2^sum)

Each number can be split in multiple ways (2^n combinations) and each requires subset sum check (2^sum)

⚠ Quadratic Growth

Space Complexity

O(2^n)

Recursive call stack and storing all possible array states

⚠ Quadratic Space

28.4K 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