Leetcode 0216: Combination Sum III

Title description:

Find all valid combinations of k numbers that sum up to n such that the following conditions are true:
Only numbers 1 through 9 are used.
Each number is used at most once.
Return a list of all possible valid combinations. The list must not contain the same combination twice, and the combinations may be returned in any order.

Example 1:

Input: k = 3, n = 7
Output: [[1,2,4]]
Explanation:
1 + 2 + 4 = 7
There are no other valid combinations.

Example 2:

Input: k = 3, n = 9
Output: [[1,2,6],[1,3,5],[2,3,4]]
Explanation:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
There are no other valid combinations.

Example 3:

Input: k = 4, n = 1
Output: []
Explanation: There are no valid combinations. [1,2,1] is not valid because 1 is used twice.

Example 4:

Input: k = 3, n = 2
Output: []
Explanation: There are no valid combinations.

Example 5:

Input: k = 9, n = 45
Output: [[1,2,3,4,5,6,7,8,9]]
Explanation:
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45
​​​​​​​There are no other valid combinations.

Constraints:

2 <= k <= 9
1 <= n <= 60

Time complexity: $O({\mathrm{C}}_9^k$ * k)
Space Complexity: $O\left(k\right)$
DFS Backtracking:
Brute force search out all k schemes selected from 9 numbers, and record all schemes whose sum is equal to n.
In order to avoid double counting, if the last selected number is x, then we start enumerating the current number from x+1.

Time complexity analysis: select k from 9 numbers, a total of ${\mathrm{C}}_9^k$It takes O(k) time to record each plan, so the time complexity is O( $C_9^k$ * k)。

class Solution {
    
    
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
    
    
        dfs(1, new ArrayList<Integer>(), k, n);
        return res;
    }
    
    private void dfs(int next, List<Integer> path, int k, int remain){
    
    
        if(k == path.size() && remain == 0){
    
    
            res.add(new ArrayList<Integer>(path));
            return;
        }
        for(int i = next; i <=9; i++){
    
    
            path.add(i);
            dfs(i+1, path, k, remain-i);
            path.remove(path.size()-1);
        }
    }
}