[ohgyulim] WEEK 03 solutions

combination-sum/ohgyulim.java

@@ -0,0 +1,25 @@
+import java.util.*;
+
+class Solution {
+    List<List<Integer>> answer = new ArrayList<>();
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        recur(new ArrayList<Integer>(), candidates, target, 0, 0);
+        return answer;
+    }
+
+    public void recur(List<Integer> result, int[] candidates, int target, int sum, int index) {
+        if (sum == target) {
+            List<Integer> deepCopyRes = new ArrayList<>(result);
+            answer.add(deepCopyRes);
+            return;
+        }
+        for (int i = index; i < candidates.length; i++) {
+            if (sum + candidates[i] <= target) {
+                result.add(candidates[i]);
+                recur(result, candidates, target, sum + candidates[i], i);
+                result.remove(Integer.valueOf(candidates[i]));
+            }
+        }
+    }
+}

decode-ways/ohgyulim.java

@@ -0,0 +1,26 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 공간 복잡도: O(N), dp배열
+    */ 
+    public int numDecodings(String s) {
+        if (s.charAt(0) == '0') return 0;
+        int[] dp = new int[s.length() + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+
+        for (int i = 2; i <= s.length(); i++) {
+            int one = Integer.parseInt(s.substring(i - 1, i));
+            int two = Integer.parseInt(s.substring(i - 2, i));
+
+            if (one > 0) {
+                dp[i] += dp[i - 1];
+            }
+            if (two >= 10 && two <= 26) {
+                dp[i] += dp[i - 2];
+            }
+        }
+        return dp[s.length()];
+    }
+}
+

maximum-subarray/ohgyulim.java

@@ -0,0 +1,17 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 공간 복잡도: O(N), dp배열
+    */ 
+    public int maxSubArray(int[] nums) {
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+
+        int answer = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
+            answer = Math.max(answer, dp[i]);
+        }
+        return answer;
+    }
+}

number-of-1-bits/ohgyulim.java

@@ -0,0 +1,10 @@
+class Solution {
+    /* 시간 복잡도: O(1)
+    * 
+    * 공간 복잡도: O(1)
+    */ 
+    public int hammingWeight(int n) {
+        return Integer.bitCount(n);
+    }
+}
+

valid-palindrome/ohgyulim.java

@@ -0,0 +1,26 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 
+    * 공간 복잡도: O(N), StringBuilder
+    */ 
+    public boolean isPalindrome(String s) {
+        StringBuilder sb = new StringBuilder();
+
+        for (char ch : s.toCharArray()) {
+            if (Character.isLetterOrDigit(ch)) {
+                sb.append(Character.toLowerCase(ch));
+            }
+        }
+
+        for (int i = 0; i < sb.length(); i++) {
+            int left = i;
+            int right = sb.length() - i - 1;
+
+            if (left >= right) return true;
+            if (sb.charAt(left) != sb.charAt(right)) return false;
+        }
+
+        return true;
+    }
+}