g0001_0100.s0039_combination_sum.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0001_0100.s0039_combination_sum;

// #Medium #Top_100_Liked_Questions #Array #Backtracking #Algorithm_II_Day_10_Recursion_Backtracking
// #Level_2_Day_20_Brute_Force/Backtracking #Udemy_Backtracking/Recursion
// #Big_O_Time_O(2^n)_Space_O(n+2^n) #2023_08_09_Time_1_ms_(100.00%)_Space_43.6_MB_(90.84%)

import java.util.ArrayList;
import java.util.List;

/**
 * 39 - Combination Sum\.
 *
 * Medium
 *
 * Given an array of **distinct** integers `candidates` and a target integer `target`, return _a list of all **unique combinations** of_ `candidates` _where the chosen numbers sum to_ `target`_._ You may return the combinations in **any order**.
 *
 * The **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
 *
 * It is **guaranteed** that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.
 *
 * **Example 1:**
 *
 * **Input:** candidates = [2,3,6,7], target = 7
 *
 * **Output:** [[2,2,3],[7]]
 *
 * **Explanation:**
 *
 *     2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
 *     7 is a candidate, and 7 = 7.
 *     These are the only two combinations. 
 *
 * **Example 2:**
 *
 * **Input:** candidates = [2,3,5], target = 8
 *
 * **Output:** [[2,2,2,2],[2,3,3],[3,5]] 
 *
 * **Example 3:**
 *
 * **Input:** candidates = [2], target = 1
 *
 * **Output:** [] 
 *
 * **Example 4:**
 *
 * **Input:** candidates = [1], target = 1
 *
 * **Output:** [[1]] 
 *
 * **Example 5:**
 *
 * **Input:** candidates = [1], target = 2
 *
 * **Output:** [[1,1]] 
 *
 * **Constraints:**
 *
 * *   `1 <= candidates.length <= 30`
 * *   `1 <= candidates[i] <= 200`
 * *   All elements of `candidates` are **distinct**.
 * *   `1 <= target <= 500`
**/
public class Solution {
    public List> combinationSum(int[] coins, int amount) {
        List> ans = new ArrayList<>();
        List subList = new ArrayList<>();
        combinationSumRec(coins.length, coins, amount, subList, ans);
        return ans;
    }

    private void combinationSumRec(
            int n, int[] coins, int amount, List subList, List> ans) {
        if (amount == 0 || n == 0) {
            if (amount == 0) {
                List base = new ArrayList<>(subList);
                ans.add(base);
            }
            return;
        }
        if (amount - coins[n - 1] >= 0) {
            subList.add(coins[n - 1]);
            combinationSumRec(n, coins, amount - coins[n - 1], subList, ans);
            subList.remove(subList.size() - 1);
        }
        combinationSumRec(n - 1, coins, amount, subList, ans);
    }
}