Minimum Operations to Form Subsequence With Target Sum in Java

Ah, the classic dilemma of trying to form a subsequence with a target sum. It’s like trying to find a parking spot in a crowded mall during the holiday season—everyone’s fighting for the same limited space, and you’re left wondering if it’s even worth the hassle. But fear not! This problem is here to test your coding mettle and your patience.

Problem Description

Imagine you have a list of integers (let’s call them your “friends”) and a target sum (your “dream vacation budget”). Your goal is to figure out the minimum number of operations needed to form a subsequence of these integers that adds up to your target sum. Sounds simple, right? Well, it’s like trying to convince your friends to chip in for that vacation—some will be on board, while others will mysteriously “forget” their wallets.

In this problem, you’ll be given a list of integers and a target sum. Your task is to determine the minimum number of operations required to achieve that target sum using the integers in the list. If it’s impossible, you’ll return -1, which is basically the coding equivalent of saying, “Sorry, no vacation for you!”

Solution Links

Before we dive into the code, here are some handy links to solutions in other languages:

Code Solution


public class Solution {
  public int minOperations(List nums, int target) {
    final int kNoMissingBit = 31;
    final int maxBit = 31;
    int ans = 0;
    int minMissingBit = kNoMissingBit;
    int[] count = new int[maxBit + 1];

    for (final int num : nums)
      ++count[(int) (Math.log(num) / Math.log(2))];

    for (int bit = 0; bit < maxBit; ++bit) {
      if ((target >> bit & 1) == 1) {
        if (count[bit] > 0)
          --count[bit];
        else
          minMissingBit = Math.min(minMissingBit, bit);
      }
      if (minMissingBit != kNoMissingBit && count[bit] > 0) {
        --count[bit];
        ans += bit - minMissingBit;
        minMissingBit = kNoMissingBit;
      }
      count[bit + 1] += count[bit] / 2;
    }
    return minMissingBit == kNoMissingBit ? ans : -1;
  }
}

Approach Explanation

The code uses a bit manipulation approach to determine how many operations are needed to form the target sum. It counts the occurrences of each power of two in the input list and checks if the bits of the target can be formed using these powers. If a required bit is missing, it tries to “borrow” from higher bits, counting the operations needed to do so.

Time and Space Complexity

Complexity Type	Complexity
Time Complexity	O(n + m), where n is the number of elements in `nums` and m is the number of bits (32).
Space Complexity	O(m), where m is the number of bits (32).

Real-World Example

Let’s say you’re planning a group trip to the beach, and you need to gather funds from your friends. Each friend has a different amount they can contribute, and you have a specific budget in mind. You need to figure out the minimum number of friends you need to convince to reach that budget. If some friends are unwilling to contribute, you might have to find creative ways to combine contributions from others. This is essentially what the problem is asking you to solve!