Sponsored
Sponsored
This approach uses backtracking to explore all possible combinations. Start with an empty combination, then add numbers incrementally and explore subsequent possibilities. If the sum of combination exceeds n or if it reaches the required length k, backtracking occurs to explore other potential combinations.
Time Complexity: O(2^n) because each number has a choice of being included or not.
Space Complexity: O(k) for the recursion stack.
1import java.util.ArrayList;
2import java.util.List;
3
4public class CombinationSum3 {
5 private void backtrack(int k, int n, int start, List<Integer> path, List<List<Integer>> results) {
6 if (k == 0 && n == 0) {
7 results.add(new ArrayList<>(path));
8 return;
9 }
10 for (int i = start; i <= 9; i++) {
11 if (i > n) break;
12 path.add(i);
13 backtrack(k - 1, n - i, i + 1, path, results);
14 path.remove(path.size() - 1);
15 }
16 }
17
18 public List<List<Integer>> combinationSum3(int k, int n) {
19 List<List<Integer>> results = new ArrayList<>();
20 backtrack(k, n, 1, new ArrayList<>(), results);
21 return results;
22 }
23
24 public static void main(String[] args) {
25 CombinationSum3 solver = new CombinationSum3();
26 List<List<Integer>> result = solver.combinationSum3(3, 7);
27 for (List<Integer> list : result) {
28 System.out.println(list);
29 }
30 }
31}This Java solution utilizes backtracking with helper function backtrack. The list path holds numbers in current sequence. Recursive calls progressively attempt further numbers, while restored elements in path enable backtracking.
This approach leverages bitmasking to generate all subsets of numbers {1,2,...,9} and filters conceivable combinations by size and sum criteria. It's potentially less intuitive, yet eliminates recursion.
Time Complexity: O(2^n), iterating through bitmask combinations for validity checks.
Space Complexity: O(k) due to maintained size of data array.
1using System.Collections.Generic;
public class CombinationSum3Iterative {
public IList<IList<int>> CombinationSum3(int k, int n) {
IList<IList<int>> result = new List<IList<int>>();
for (int mask = 0; mask < (1 << 9); ++mask) {
List<int> comb = new List<int>();
int sum = 0;
for (int i = 0; i < 9; ++i) {
if ((mask & (1 << i)) != 0) {
sum += (i + 1);
comb.Add(i + 1);
}
}
if (comb.Count == k && sum == n) {
result.Add(new List<int>(comb));
}
}
return result;
}
public static void Main() {
CombinationSum3Iterative solution = new CombinationSum3Iterative();
var result = solution.CombinationSum3(3, 7);
foreach (var set in result) {
Console.WriteLine(string.Join(", ", set));
}
}
}The C# solution is aligned with bitmasking, iterating interaction courses through all potential 512 number uses outcomes from 1 to 9. Filtered results meeting specification are simply recorded in final result.