- Add: Java solutions

Author: BNSC1

LeetCode/33. Search in Rotated Sorted Array.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int size = nums.length;
+        int start = 0;
+        int end = size - 1;
+        while (start <= end) {
+            int mid = (end + start) / 2;
+            if (nums[mid] == target) return mid;
+            if (nums[start] > nums[mid]) {
+                if (target > nums[end] ||
+                    target < nums[mid]) end = mid - 1;
+                else start = mid + 1;
+            } else {
+                if (target < nums[start] ||
+                    target > nums[mid]) start = mid + 1;
+                else end = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+} //TC: O(logn), SC: O(1)

LeetCode/39. Combination Sum.java

@@ -0,0 +1,17 @@
+class Solution {
+    public List<List<Integer>> combinationSum(int[] cands, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        class Helper {
+            void backtrack(int i, List<Integer> cur, int diff) {
+                if (diff == 0) res.add(new ArrayList<>(cur));
+                if (i >= cands.length || diff <= 0) return;
+                cur.add(cands[i]);
+                backtrack(i, cur, diff - cands[i]);
+                cur.remove(cur.size() - 1);
+                backtrack(i + 1, cur, diff);
+            }
+        }
+        new Helper().backtrack(0, new ArrayList<>(), target);
+        return res;
+    }
+} //TC: O(N^(M/T + 1)), SC: O(T/M), where T is the target value, N is the number of candidates, M is the smallest candidate among all the given integers