[JeonJe] WEEK 03 Solutions

combination-sum/JeonJe.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+// TC: O(n^(target/min))
+// SC: O(target/min)
+class Solution {
+    private static List<List<Integer>> answer;
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        answer = new ArrayList<>();
+
+        List<Integer> bucket = new ArrayList<>();
+        int curSum = 0;
+
+        dfs(candidates, bucket, target, 0, 0);
+
+        return answer;
+    }
+
+    private void dfs(int[] candidates, List<Integer> bucket, int target, int startIdx, int curSum) {
+        if (curSum == target) {
+            answer.add(new ArrayList<>(bucket));
+            return;
+        }
+        if (curSum > target)
+            return;
+
+        for (int i = startIdx; i < candidates.length; i++) {
+            bucket.add(candidates[i]);
+            dfs(candidates, bucket, target, i, curSum + candidates[i]);
+            bucket.removeLast();
+        }
+
+    }
+}

decode-ways/JeonJe.java

@@ -0,0 +1,24 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public int numDecodings(String s) {
+        int n = s.length();
+        int[] dp = new int[n + 1];
+        dp[n] = 1;
+
+        for (int i = s.length() - 1; i >= 0; i--) {
+            if (s.charAt(i) != '0') {
+                dp[i] = dp[i + 1];
+            }
+            if (i + 1 < n) {
+                int twoDigit = Integer.parseInt(s.substring(i, i + 2));
+                if (twoDigit >= 10 && twoDigit <= 26) {
+                    dp[i] += dp[i + 2];
+                }
+            }
+        }
+        return dp[0];
+    }
+}

maximum-subarray/JeonJe.java

@@ -0,0 +1,20 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n];
+
+        dp[n - 1] = nums[n - 1];
+        int answer = dp[n - 1];
+
+        for (int i = n - 2; i >= 0; i--) {
+            dp[i] = Math.max(dp[i + 1] + nums[i], nums[i]);
+            answer = Math.max(answer, dp[i]);
+        }
+
+        return answer;
+    }
+}

number-of-1-bits/JeonJe.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+// TC: O(1)
+// SC: O(1)
+class Solution {
+    public int hammingWeight(int n) {
+        int answer = 0;
+
+        while (n != 0) {
+            if ((n & 1) == 1) {
+                answer++;
+            }
+            n = n >>> 1;
+        }
+        return answer;
+    }
+}

valid-palindrome/JeonJe.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public boolean isPalindrome(String s) {
+        StringBuilder sb = new StringBuilder();
+
+        for (char c : s.toCharArray()) {
+            if (Character.isLetterOrDigit(c)) {
+                sb.append(Character.toLowerCase(c));
+            }
+        }
+
+        for (int i = 0; i < sb.length() / 2; i++) {
+            if (sb.charAt(i) != sb.charAt(sb.length() - 1 - i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+}