Generate All Combinations Sum K in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the problem 'Generate All Combinations Sum K' ask you to find?

It asks to find all unique combinations of numbers from a given list that add up exactly to a target sum K.

beginner

Which algorithmic technique is commonly used to solve 'Generate All Combinations Sum K'?

Backtracking is commonly used because it explores all possible combinations and abandons paths that exceed the target sum.

intermediate

In backtracking for combinations sum K, why do we sort the input array first?

Sorting helps to stop early when the current number exceeds the remaining sum and to avoid duplicate combinations.

intermediate

What is the role of the 'start index' in the recursive backtracking function for combinations sum K?

It ensures combinations are built without reusing previous elements and avoids duplicates by moving forward in the list.

advanced

How do you avoid duplicate combinations when the input list contains repeated numbers?

Skip over numbers that are the same as the previous one at the same recursive level to prevent duplicate combinations.

What is the main purpose of backtracking in generating combinations that sum to K?

A To find the maximum number in the list

B To sort the input array

C To multiply numbers to reach K

D To explore all possible combinations and discard invalid ones early

Backtracking explores all combinations and stops exploring paths that exceed the target sum.

Why do we pass a 'start index' in the recursive call when generating combinations?

A To avoid reusing elements before the start index and prevent duplicates

B To reset the sum to zero

C To sort the array again

D To multiply the current sum

The start index moves forward to avoid reusing elements and duplicates.

What should you do when the current sum exceeds K during backtracking?

A Add more numbers

B Stop exploring this path and backtrack

C Reset the sum to zero

D Sort the array

If sum exceeds K, no need to continue; backtrack to try other combinations.

How can sorting the input array help in generating combinations sum K?

A It helps to stop early when numbers exceed the remaining sum

B It changes the target sum

C It removes duplicates automatically

D It multiplies the numbers

Sorting allows early stopping when current number is too big.

When the input list has duplicates, how do you avoid duplicate combinations?

A Sort the array in descending order

B Use all duplicates every time

C Skip numbers that are the same as the previous one at the same recursion level

D Add duplicates multiple times

Skipping duplicates at the same level prevents repeated combinations.

Explain how backtracking works to generate all combinations that sum to K.

Think about exploring all paths and undoing choices.

Describe how to handle duplicates in the input list when generating combinations sum K.

Sorting helps to detect duplicates easily.

Practice

1. What does the problem "Generate All Combinations Sum K" ask you to find?

easy

A. All unique combinations of numbers that add up to K

B. The largest number less than K

C. The sum of all numbers from 1 to K

D. The product of all numbers that divide K

Solution

1. Step 1: Understand the problem goal

   The problem asks to find all unique sets of numbers that add exactly to the target sum K.

2. Step 2: Clarify what combinations mean

   Combinations mean selecting numbers without caring about order, but each combination must sum to K.

3. Final Answer:

   All unique combinations of numbers that add up to K -> Option A

4. Quick Check:

   Sum of combinations = K [OK]

Hint: Focus on sums equal to K, not order or multiplication [OK]

Common Mistakes:

• Confusing combinations with permutations
• Looking for product instead of sum
• Ignoring uniqueness of combinations

2. Which of the following Java method signatures is correct for a function that generates all combinations summing to K using backtracking?

easy

A. public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start)

B. public int findCombinations(int[] nums, int target)

C. void findCombinations(int target, int[] nums, List result)

D. public List<Integer> findCombinations(int target, int[] nums)

Solution

1. Step 1: Identify parameters needed for backtracking

   We need the array, target sum, current combination list, result list, and start index to avoid duplicates.

2. Step 2: Match method signature with these parameters

   public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) matches all needed parameters and returns void as it fills the result list.

3. Final Answer:

   public void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) -> Option A

4. Quick Check:

   Correct parameters for backtracking method [OK]

Hint: Backtracking needs current, result lists, and start index [OK]

Common Mistakes:

• Missing start index parameter
• Wrong return type for backtracking method
• Incorrect parameter order

3. What will be the output of the following Java code snippet?

List result = new ArrayList<>();
int[] nums = {2, 3, 6, 7};
int target = 7;
findCombinations(nums, target, new ArrayList<>(), result, 0);
System.out.println(result);

Assuming findCombinations correctly finds all unique combinations summing to target.

medium

A. [[2, 3, 6], [7]]

B. [[7]]

C. [[2, 2, 3], [7]]

D. [[2, 2, 2, 3], [7]]

Solution

1. Step 1: Identify combinations that sum to 7

   From nums, 7 alone sums to 7, and 2+2+3 also sums to 7.

2. Step 2: Confirm no other combinations sum to 7

   3+6=9, 2+3+6=11, 2+2+2+3=9 (too large), so only [2,2,3] and [7] are valid.

3. Final Answer:

   [[2, 2, 3], [7]] -> Option C

4. Quick Check:

   Valid combinations sum to 7 [OK]

Hint: Check sums carefully; only valid combos appear [OK]

Common Mistakes:

• Including invalid sums
• Missing repeated elements allowed
• Confusing order of elements

4. Identify the error in this Java backtracking code snippet for generating combinations summing to K:

void findCombinations(int[] nums, int target, List<Integer> current, List result, int start) {
    if (target == 0) {
        result.add(new ArrayList<>(current));
        return;
    }
    for (int i = start; i < nums.length; i++) {
        if (nums[i] > target) continue;
        current.add(nums[i]);
        findCombinations(nums, target - nums[i], current, result, i);
        current.remove(current.size());
    }
}

medium

A. The recursive call should use i + 1 instead of i

B. The base case should check if target < 0 instead of target == 0

C. The loop should start from 0 instead of start

D. Removing element with current.remove(current.size()) causes IndexOutOfBoundsException

Solution

1. Step 1: Check the remove method usage

   List indices start at 0, so last element index is current.size() - 1, not current.size().

2. Step 2: Identify correct remove call

   Using current.remove(current.size()) causes IndexOutOfBoundsException because index is out of range.

3. Final Answer:

   Removing element with current.remove(current.size()) causes IndexOutOfBoundsException -> Option D

4. Quick Check:

   List remove index must be size-1 [OK]

Hint: Remove last element with index size-1, not size [OK]

Common Mistakes:

• Removing element at wrong index
• Ignoring base case correctness
• Wrong loop start index

5. Given the array nums = {1, 2, 3} and target sum 4, which of the following is the correct set of all unique combinations where numbers can be repeated and sum to 4?

hard

A. [[1,1,1,1], [1,1,2], [1,3], [2,2], [3,1]]

B. [[1,1,1,1], [1,1,2], [1,3], [2,2]]

C. [[1,1,1,1], [1,1,2], [1,3], [2,2], [4]]

D. [[1,1,1,1], [1,1,2], [2,2], [3,1]]

Solution

1. Step 1: List all combinations summing to 4 with repeats allowed

   Possible combos: [1,1,1,1], [1,1,2], [1,3], [2,2]. Note [3,1] is same as [1,3] and duplicates are not allowed.

2. Step 2: Check options for duplicates and invalid elements

   [[1,1,1,1], [1,1,2], [1,3], [2,2], [3,1]] includes [3,1] duplicate of [1,3]. [[1,1,1,1], [1,1,2], [1,3], [2,2], [4]] includes [4] which is not in nums. [[1,1,1,1], [1,1,2], [2,2], [3,1]] misses [1,3]. [[1,1,1,1], [1,1,2], [1,3], [2,2]] correctly lists unique combinations.

3. Final Answer:

   [[1,1,1,1], [1,1,2], [1,3], [2,2]] -> Option B

4. Quick Check:

   Unique combos sum to 4 without duplicates [OK]

Hint: Avoid duplicates by sorting or fixed order in combos [OK]

Common Mistakes:

• Counting duplicates as separate combinations
• Including numbers not in the array
• Ignoring repeated use of numbers