Merge pull request #374 from TonyKim9401/main

[TONY] WEEK 03 Solutions

Author: TonyKim9401

climbing-stairs/TonyKim9401.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int climbStairs(int n) {
+        // Time complexity: O(n);
+        // Space complexity: O(n);
+        int[] dp = new int[n+1];
+
+        if (n >= 1) dp[1] = 1;
+        if (n >= 2) dp[2] = 2;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+        return dp[n];
+    }
+}

coin-change/TonyKim9401.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        // TC: O(amount*n)
+        // SC: O(amount)
+        int[] dp = new int[amount + 1];
+        Arrays.fill(dp, amount + 1);
+
+        dp[0] = 0;
+
+        for (int i = 1; i <= amount; i++) {
+            for (int j = 0; j < coins.length; j++) {
+                if (i - coins[j] >= 0) {
+                    dp[i] = Math.min(dp[i], 1 + dp[i - coins[j]]);
+                }
+            }
+        }
+        return dp[amount] != amount + 1 ? dp[amount] : -1;
+    }
+}

combination-sum/TonyKim9401.java

@@ -0,0 +1,23 @@
+class Solution {
+    // time complexity: O(2^n);
+    // space complecity: O(n*m);
+    private List<List<Integer>> output = new ArrayList<>();
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        backtracking(candidates, 0, target, new ArrayList<>());
+        return output;
+    }
+
+    public void backtracking(int[] candidates, int idx, int target, List<Integer> inside) {
+        if (target == 0) {
+            output.add(new ArrayList<>(inside));
+            return;
+        }
+
+        if (idx > candidates.length - 1 || target < 0) return;
+
+        inside.add(candidates[idx]);
+        backtracking(candidates, idx, target - candidates[idx], inside);
+        inside.remove(inside.size()-1);
+        backtracking(candidates, idx+1, target, inside);
+    }
+}

product-of-array-except-self/TonyKim9401.java

@@ -0,0 +1,29 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        // time complexity: O(n)
+        // space complexity: O(n)
+        int[] left = new int[nums.length];
+        int[] right = new int[nums.length];
+
+        // nums =  [1,  2,  3, 4]
+
+        // left =  [1,  1,  2, 6]
+        // right = [24, 12, 4, 1]
+
+        // nums => [24, 12, 8, 6]
+        left[0] = 1;
+        for (int i = 1; i < nums.length; i++) {
+            left[i] = left[i-1] * nums[i-1];
+        }
+
+        right[right.length-1] = 1;
+        for (int i = nums.length - 2; i >= 0; i--) {
+            right[i] = right[i+1] * nums[i+1];
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            nums[i] = left[i] * right[i];
+        }
+        return nums;
+    }
+}

two-sum/TonyKim9401.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        // time complexity: O(n);
+        // space complexity: O(n);
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) map.put(nums[i], i);
+
+        for (int i = 0; i < nums.length; i++) {
+            int candidateKey = target - nums[i];
+            if (map.containsKey(candidateKey) && i != map.get(candidateKey))
+                return new int[]{i, map.get(candidateKey)};
+        }
+        return new int[]{-1, -1};
+    }
+}