Add C++ implementation

Signed-off-by: begeekmyfriend <[email protected]>

Author: begeekmyfriend

0039_combination_sum/combination_sum.cc

@@ -5,14 +5,14 @@ using namespace std;
 class Solution {
 public:
     vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
-        vector<int> stack;
         vector<vector<int>> res;
-        dfs(candidates, 0, target, stack, res);
+        dfs(candidates, 0, target, res);
         return res;
     }
 
 private:
-    void dfs(vector<int>& candidates, int start, int target, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& candidates, int start, int target, vector<vector<int>>& res) {
         if (target < 0) {
             return;
         } else if (target == 0) {
@@ -21,7 +21,7 @@ class Solution {
             for (int i = start; i < candidates.size(); i++) {
                 stack.push_back(candidates[i]);
                 /* The elements in solution can be duplicate for the purpose of the problem */
-                dfs(candidates, i, target - candidates[i], stack, res);
+                dfs(candidates, i, target - candidates[i], res);
                 stack.pop_back();
             }
         }

0040_combination_sum_ii/combination_sum.c

@@ -25,7 +25,7 @@ static void dfs(int *nums, int size, int start, int target, int *solution,
         int last = INT_MIN;
         for (i = start; i < size; i++) {
             if (last != nums[i]) {
-                /* No duplicate combinations in different order */
+                /* No duplicate combinations in the same level position */
                 solution[len] = nums[i];
                 /* i + 1 limits the candidate range in next levels */
                 dfs(nums, size, i + 1, target - nums[i], solution, len + 1, results, count, column_sizes);

0040_combination_sum_ii/combination_sum.cc

@@ -5,15 +5,15 @@ using namespace std;
 class Solution {
 public:
     vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
-        vector<int> stack;
         vector<vector<int>> res;
         sort(candidates.begin(), candidates.end());
-        dfs(candidates, 0, target, stack, res);
+        dfs(candidates, 0, target, res);
         return res;
     }
 
 private:
-    void dfs(vector<int>& candidates, int start, int target, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& candidates, int start, int target, vector<vector<int>>& res) {
         if (target < 0) {
             return;
         } else if (target == 0) {
@@ -22,10 +22,10 @@ class Solution {
             int last = INT_MIN;
             for (int i = start; i < candidates.size(); i++) {
                 if (last != candidates[i]) {
-                    /* No duplicate combinations in different order */
+                    /* No duplicate combinations in the same level position */
                     stack.push_back(candidates[i]);
                     /* i + 1 limits the candidate range in next levels */
-                    dfs(candidates, i + 1, target - candidates[i], stack, res);
+                    dfs(candidates, i + 1, target - candidates[i], res);
                     stack.pop_back();
                 }
                 last = candidates[i];

0046_permutations/permutations.cc

@@ -6,14 +6,14 @@ class Solution {
 public:
     vector<vector<int>> permute(vector<int>& nums) {
         vector<vector<int>> res;
-        vector<int> stack;
         vector<bool> used(nums.size());
-        dfs(nums, used, stack, res);
+        dfs(nums, used, res);
         return res;
     }
 
 private:
-    void dfs(vector<int>& nums, vector<bool>& used, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& nums, vector<bool>& used, vector<vector<int>>& res) {
         if (stack.size() == nums.size()) {
             res.push_back(stack);
         } else {
@@ -23,7 +23,7 @@ class Solution {
                     // Used marks only allows remaining elements in DFS levels
                     used[i] = true;
                     stack.push_back(nums[i]);
-                    dfs(nums, used, stack, res);
+                    dfs(nums, used, res);
                     stack.pop_back();
                     used[i] = false;
                 }

0047_permutations_ii/permutations.c

@@ -23,7 +23,8 @@ static void dfs(int *nums, int size, bool *used, int *stack,
             /* Used marks only allows remaining elements in DFS levels */
             if (!used[i]) {
                 if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
-                    /* In case that duplicate permutation with same elemements but in different postions */
+                    /* In case duplicate permutation with same elemements in the same postion */
+                    /* used[i - 1] == true means different level position */
                     continue;
                 }
                 used[i] = true;

0047_permutations_ii/permutations.cc

@@ -6,28 +6,29 @@ class Solution {
 public:
     vector<vector<int>> permuteUnique(vector<int>& nums) {
         vector<vector<int>> res;
-        vector<int> stack;
         vector<bool> used(nums.size());
         sort(nums.begin(), nums.end());
-        dfs(nums, used, stack, res);
+        dfs(nums, used, res);
         return res;
     }
 
 private:
-    void dfs(vector<int>& nums, vector<bool>& used, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& nums, vector<bool>& used, vector<vector<int>>& res) {
         if (stack.size() == nums.size()) {
             res.push_back(stack);
         } else {
             for (int i = 0; i < nums.size(); i++) {
                 // Used marks only allows remaining elements in DFS levels
                 if (!used[i]) {
                     if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
-                        // In case that duplicate permutation with same elemements but in different postions
+                        // In case duplicate permutation with same elemements in the same postion
+                        // used[i - 1] == true means different level position
                         continue;
                     }
-                    used[i] = true;
                     stack.push_back(nums[i]);
-                    dfs(nums, used, stack, res);
+                    used[i] = true;
+                    dfs(nums, used, res);
                     stack.pop_back();
                     used[i] = false;
                 }

0077_combinations/combinations.c

@@ -27,12 +27,10 @@ static void dfs(int n, int k, int start, int *stack, int len,
  */
 int** combine(int n, int k, int* returnSize, int** returnColumnSizes) {
     int capacity = 10000;
-    int count = 0;
     int **results = malloc(capacity * sizeof(int *));
     int *stack = malloc(k * sizeof(int));
     *returnColumnSizes = malloc(capacity * sizeof(int));
-    dfs(n, k, 1, stack, 0, results, &count, *returnColumnSizes);
-    *returnSize = count;
+    dfs(n, k, 1, stack, 0, results, returnSize, *returnColumnSizes);
     return results;
 }
 
@@ -43,8 +41,15 @@ int main(int argc, char **argv)
         exit(-1);
     }
 
+    int n = atoi(argv[1]);
+    int k = atoi(argv[2]);
+    if (k > n) {
+        fprintf(stderr, "n(=%d) must larger than k(=%d)\n", n, k);
+        exit(-1);
+    }
+
     int i, j, *col_sizes, count = 0;
-    int **lists = combine(atoi(argv[1]), atoi(argv[2]), &count, &col_sizes);
+    int **lists = combine(n, k, &count, &col_sizes);
     for (i = 0; i < count; i++) {
         for (j = 0; j < col_sizes[i]; j++) {
             printf("%d ", lists[i][j]);

0077_combinations/combinations.cc

@@ -6,19 +6,19 @@ class Solution {
 public:
     vector<vector<int>> combine(int n, int k) {
         vector<vector<int>> res;
-        vector<int> stack;
-        dfs(n, k, 1, stack, res);
+        dfs(n, k, 1, res);
         return res;
     }
 
 private:
-    void dfs(int n, int k, int start, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(int n, int k, int start, vector<vector<int>>& res) {
         if (stack.size() == k) {
             res.push_back(stack);
         } else {
             for (int i = start; i <= n; i++) {
                 stack.push_back(i);
-                dfs(n, k, i + 1, stack, res);
+                dfs(n, k, i + 1, res);
                 stack.pop_back();
             }
         }

0078_subsets/subsets.cc

@@ -6,17 +6,17 @@ class Solution {
 public:
     vector<vector<int>> subsets(vector<int>& nums) {
         vector<vector<int>> res;
-        vector<int> stack;
-        dfs(nums, 0, stack, res);
+        dfs(nums, 0, res);
         return res;    
     }
 
 private:
-    void dfs(vector<int>& nums, int start, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& nums, int start, vector<vector<int>>& res) {
         res.push_back(stack);
         for (int i = start; i < nums.size(); i++) {
             stack.push_back(nums[i]);
-            dfs(nums, i + 1, stack, res);
+            dfs(nums, i + 1, res);
             stack.pop_back();
         }
     }

0090_subsets_ii/subsets.cc

@@ -6,21 +6,21 @@ class Solution {
 public:
     vector<vector<int>> subsetsWithDup(vector<int>& nums) {
         vector<vector<int>> res;
-        vector<int> stack;
         sort(nums.begin(), nums.end());
-        dfs(nums, 0, stack, res);
+        dfs(nums, 0, res);
         return res;    
     }
 
 private:
-    void dfs(vector<int>& nums, int start, vector<int>& stack, vector<vector<int>>& res) {
+    vector<int> stack;
+    void dfs(vector<int>& nums, int start, vector<vector<int>>& res) {
         res.push_back(stack);
         int last = INT_MIN;
         for (int i = start; i < nums.size(); i++) {
             if (last != nums[i]) {
-                /* No duplicate candidate elements at same level position */
+                /* No duplicate candidate elements in the same level position */
                 stack.push_back(nums[i]);
-                dfs(nums, i + 1, stack, res);
+                dfs(nums, i + 1, res);
                 stack.pop_back();
             }
             last = nums[i];

0216_combination_sum_iii/combination_sum.cc

@@ -0,0 +1,27 @@
+#include <stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> combinationSum3(int k, int n) {
+        vector<vector<int>> res;
+        dfs(1, 9, k, n, res);
+        return res;
+    }
+private:
+    vector<int> stack;
+    void dfs(int start, int size, int k, int target, vector<vector<int>>& res) {
+        if (stack.size() == k) {
+            if (target == 0) {
+                res.push_back(stack);
+            }
+        } else {
+            for (int i = start; i <= size; i++) {
+                stack.push_back(i);
+                dfs(i + 1, size, k, target - i, res);
+                stack.pop_back();
+            }
+        }
+    }
+};