Update readme.md

Author: javadev

src/main/java/g0001_0100/s0039_combination_sum/readme.md

@@ -33,4 +33,55 @@ The test cases are generated such that the number of unique combinations that su
 *   `1 <= candidates.length <= 30`
 *   `2 <= candidates[i] <= 40`
 *   All elements of `candidates` are **distinct**.
-*   `1 <= target <= 40`
+*   `1 <= target <= 40`
+
+To solve the "Combination Sum" problem in Java with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `combinationSum` that takes an array of integers `candidates` and an integer `target` as input and returns a list of lists containing all unique combinations of `candidates` where the chosen numbers sum to `target`.
+3. Implement backtracking to explore all possible combinations of candidates.
+4. Sort the `candidates` array to ensure that duplicates are grouped together.
+5. Create a recursive helper method named `backtrack` that takes parameters:
+   - A list to store the current combination.
+   - An integer representing the starting index in the `candidates` array.
+   - The current sum of the combination.
+6. In the `backtrack` method:
+   - If the current sum equals the target, add the current combination to the result list.
+   - Iterate over the candidates starting from the current index.
+   - Add the current candidate to the combination.
+   - Recursively call the `backtrack` method with the updated combination, index, and sum.
+   - Remove the last added candidate from the combination to backtrack.
+7. Call the `backtrack` method with an empty combination list, starting index 0, and sum 0.
+8. Return the result list containing all unique combinations.
+
+Here's the implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(candidates); // Sort the candidates to ensure duplicates are grouped together
+        backtrack(result, new ArrayList<>(), candidates, target, 0);
+        return result;
+    }
+
+    private void backtrack(List<List<Integer>> result, List<Integer> combination, int[] candidates, int target, int start) {
+        if (target == 0) {
+            result.add(new ArrayList<>(combination));
+            return;
+        }
+
+        for (int i = start; i < candidates.length && candidates[i] <= target; i++) {
+            combination.add(candidates[i]);
+            backtrack(result, combination, candidates, target - candidates[i], i); // Use the same candidate again
+            combination.remove(combination.size() - 1); // Backtrack by removing the last candidate
+        }
+    }
+}
+```
+
+This implementation provides a solution to the "Combination Sum" problem in Java. It explores all possible combinations of candidates using backtracking and returns the unique combinations whose sum equals the target.