Add C++ implementation

Signed-off-by: begeekmyfriend <begeekmyfriend@gmail.com>

Author: begeekmyfriend

036_valid_sudoku/valid_sudoku.cc

@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    bool isValidSudoku(vector<vector<char>>& board) {
+        /* check row validity */
+        for (int i = 0; i < board.size(); i++) {
+            vector<bool> mark(10);
+            /* check row validity */
+            for (int j = 0; j < board.size(); j++) {
+                if (!valid(board, mark, i, j)) {
+                    return false;
+                }
+            }
+        }
+
+        /* check column validity */
+        for (int j = 0; j < board.size(); j++) {
+            vector<bool> mark(10);
+            for (int i = 0; i < board.size(); i++) {
+                if (!valid(board, mark, i, j)) {
+                    return false;
+                }
+            }
+        }
+
+        /* check sub-box validity */
+        for (int k = 0; k < board.size(); k++) {
+            int sr = k / 3 * 3;
+            int sc = (k % 3) * 3;
+            vector<bool> mark(10);
+            for (int i = sr; i < sr + 3; i++) {
+                for (int j = sc; j < sc + 3; j++) {
+                    if (!valid(board, mark, i, j)) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+private:
+    bool valid(vector<vector<char>>& board, vector<bool>& mark, int i, int j) {
+        if (board[i][j] != '.') {
+            int index = board[i][j] - '0';
+            if (mark[index]) {
+                return false;
+            } else {
+                mark[index] = 1;
+            }
+        }
+        return true;
+    }
+};

037_sudoku_solver/sudoku_solver.cc

@@ -0,0 +1,67 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    void solveSudoku(vector<vector<char>>& board) {
+        int size = board.size();
+        vector<vector<bool>> rows(size, vector<bool>(10));
+        vector<vector<bool>> cols(size, vector<bool>(10));
+        vector<vector<bool>> boxes(size, vector<bool>(10));
+
+        for (int i = 0; i < size; i++) {
+            for (int j = 0; j < size; j++) {
+                if (board[i][j] != '.') {
+                    int num = board[i][j] - '0';
+                    int idx = i / 3 * 3 + j / 3;
+                    rows[i][num] = true;
+                    cols[j][num] = true;
+                    boxes[idx][num] = true;
+                }
+            }
+        }
+
+        dfs(board, 0, rows, cols, boxes);
+    }
+
+private:
+    bool valid(int num, int row, int col, int idx, vector<vector<bool>>& rows,
+               vector<vector<bool>>& cols, vector<vector<bool>>& boxes) {
+        return !rows[row][num] && !cols[col][num] && !boxes[idx][num];
+    }
+
+    bool dfs(vector<vector<char>>& board, int size, vector<vector<bool>>& rows,
+             vector<vector<bool>>& cols, vector<vector<bool>>& boxes) {
+        if (size == 9 * 9) {
+            return true;
+        } else {
+            bool ok = false;
+            int row = size / 9;
+            int col = size % 9;
+            int idx = row / 3 * 3 + col / 3;
+            if (board[row][col] == '.') {
+                for (int i = 1; i <= 9; i++) {
+                    if (valid(i, row, col, idx, rows, cols, boxes)) {
+                        /* lock this grid as well as the number */
+                        board[row][col] = i + '0';
+                        rows[row][i] = true;
+                        cols[col][i] = true;
+                        boxes[idx][i] = true;
+                        ok = dfs(board, size + 1, rows, cols, boxes);
+                        if (!ok) {
+                            /* release this grid as well as the number */
+                            rows[row][i] = false;
+                            cols[col][i] = false;
+                            boxes[idx][i] = false;
+                            board[row][col] = '.';
+                        }
+                    }
+                }
+            } else {
+                ok = dfs(board, size + 1, rows, cols, boxes);
+            }
+            return ok;
+        }
+    }
+};

039_combination_sum/combination_sum.cc

@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+
+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);
+        return res;
+    }
+
+private:
+    void dfs(vector<int>& candidates, int start, int target, vector<int>& stack, vector<vector<int>>& res) {
+        if (target < 0) {
+            return;
+        } else if (target == 0) {
+            res.push_back(stack);
+        } else {
+            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);
+                stack.pop_back();
+            }
+        }
+    }
+};

040_combination_sum_ii/combination_sum.cc

@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+
+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);
+        return res;
+    }
+
+private:
+    void dfs(vector<int>& candidates, int start, int target, vector<int>& stack, vector<vector<int>>& res) {
+        if (target < 0) {
+            return;
+        } else if (target == 0) {
+            res.push_back(stack);
+        } else {
+            int last = -1;
+            for (int i = start; i < candidates.size(); i++) {
+                if (last != candidates[i]) {
+                    /* No duplicate combinations in different order */
+                    stack.push_back(candidates[i]);
+                    /* i + 1 limits the candidate range in next levels */
+                    dfs(candidates, i + 1, target - candidates[i], stack, res);
+                    stack.pop_back();
+                }
+                last = candidates[i];
+            }
+        }
+    }
+};

041_first_missing_positive/missing_positive.cc

@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    int firstMissingPositive(vector<int>& nums) {
+        if (nums.size() == 0) {
+            return 1;
+        }
+
+        int i = 0;
+        while (i < nums.size()) {
+            /* nums[i] should be i+1 and nums[nums[i] - 1] should be nums[i] */
+            if (nums[i] > 0 && nums[i] != i + 1 && nums[i] - 1 < nums.size() && nums[nums[i] - 1] != nums[i]) {
+                // Let nums[nums[i] - 1] = nums[i]
+                swap(nums[i], nums[nums[i] - 1]);
+            } else {
+                i++;
+            }
+        }
+
+        for (i = 0; i < nums.size(); i++) {
+            if (nums[i] != i + 1) {
+                break;
+            }
+        }
+
+        return i + 1;
+    }
+};

042_trapping_rain_water/trap_water.cc

@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        /* In fact if we find the relative higher bar position and then the
+         * water level of the position would be determined by the opposite side.
+         */
+        int res = 0;
+        int left = 0, left_max = 0;
+        int right = height.size() - 1, right_max = 0;
+        while (left < right) {
+            if (height[left] < height[right]) {
+                if (height[left] > left_max) {
+                    left_max = height[left];
+                } else {
+                    res += left_max - height[left];
+                }
+                left++;
+            } else {
+                if (height[right] > right_max) {
+                    right_max = height[right];
+                } else {
+                    res += right_max - height[right];
+                }
+                right--;
+            }
+        }
+
+        return res;
+    }
+};

043_multiply_strings/multiply_strings.cc

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    string multiply(string num1, string num2) {
+        string res(num1.length() + num2.length(), '0');
+        for (int i = num2.length() - 1; i >= 0; i--) {
+            int j, carry = 0;
+            for (j = num1.length() - 1; j >= 0; j--) {
+                carry += (num1[j] - '0') * (num2[i] - '0') + (res[i + j + 1] - '0');
+                res[i + j + 1] = carry % 10 + '0';
+                carry /= 10;
+            }
+            res[i + j + 1] = carry + '0';
+        }
+
+        int i;
+        for (i = 0; i < res.length() - 1; i++) {
+            if (res[i] != '0') {
+                break;
+            }
+        }
+        return res.substr(i);
+    }
+};

045_jump_game_ii/jump_game.cc

@@ -0,0 +1,24 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    int jump(vector<int>& nums) {
+        int steps = 0;
+        int lo = 0, hi = 0;
+        while (hi < nums.size() - 1) {
+            int right = 0;
+            for (int i = lo; i <= hi; i++) {
+                // right > hi for nums[i] > 0 
+                right = max(i + nums[i], right);
+            }
+            // [lo, hi] is the next location range 
+            lo = hi + 1;
+            hi = right;
+            steps++;
+        }
+
+        return steps;
+    }
+};

046_permutations/permutations.cc

@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+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);
+        return res;
+    }
+
+private:
+    void dfs(vector<int>& nums, vector<bool>& used, vector<int>& stack, vector<vector<int>>& res) {
+        if (stack.size() == nums.size()) {
+            res.push_back(stack);
+        } else {
+            for (int i = 0; i < nums.size(); i++) {
+                if (!used[i]) {
+                    used[i] = true;
+                    stack.push_back(nums[i]);
+                    dfs(nums, used, stack, res);
+                    stack.pop_back();
+                    used[i] = false;
+                }
+            }
+        }
+    }
+};

047_permutations_ii/permutations.cc

@@ -0,0 +1,37 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+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);
+        return res;
+    }
+
+private:
+    void dfs(vector<int>& nums, vector<bool>& used, vector<int>& stack, vector<vector<int>>& res) {
+        if (stack.size() == nums.size()) {
+            res.push_back(stack);
+        } else {
+            for (int i = 0; i < nums.size(); i++) {
+                if (!used[i]) {
+                    if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
+                        /* In case that duplicate permutation with same elemements */
+                        /* Used marks allow same elements in different DFS levels */
+                        continue;
+                    }
+                    used[i] = true;
+                    stack.push_back(nums[i]);
+                    dfs(nums, used, stack, res);
+                    stack.pop_back();
+                    used[i] = false;
+                }
+            }
+        }
+    }
+};