Merge pull request #788 from minji-go/main

[minji-go] Week 3

Author: minji-go

combination-sum/minji-go.java

@@ -0,0 +1,33 @@
+/*
+    Problem: https://leetcode.com/problems/combination-sum/
+    Description: return a list of all unique combinations of candidates where the chosen numbers sum to target
+    Concept: Array, Backtracking
+    Time Complexity: O(Nⁿ), Runtime 2ms
+    Space Complexity: O(N), Memory 44.88MB
+
+    - Time Complexity, Space Complexity를 어떻게 계산해야할지 어렵네요 :(
+*/
+class Solution {
+    public List<List<Integer>> answer = new ArrayList<>();
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        findCombination(candidates, target, new ArrayList<>(), 0);
+        return answer;
+    }
+
+    public void findCombination(int[] candidates, int target, List<Integer> combination, int idx) {
+        if(target == 0) {
+            answer.add(new ArrayList<>(combination));
+            return;
+        }
+
+        for(int i=idx; i<candidates.length; i++) {
+            if(candidates[i] > target) break;
+
+            combination.add(candidates[i]);
+            findCombination(candidates, target-candidates[i], combination, i);
+            combination.remove(combination.size()-1);
+        }
+    }
+}

construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java

@@ -2,7 +2,7 @@
     Problem: https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
     Description: Given two integer arrays preorder and inorder, construct and return the binary tree.
     Concept: Array, Hash Table, Divide and Conquer, Tree, Binary Tree
-    Time Complexity: O(NM), Runtime 2ms
+    Time Complexity: O(N²), Runtime 2ms
     Space Complexity: O(N), Memory 45.02MB
 */
 import java.util.HashMap;

maximum-subarray/minji-go.java

@@ -0,0 +1,18 @@
+/*
+    Problem: https://leetcode.com/problems/maximum-subarray/
+    Description: return the largest sum of the subarray, contiguous non-empty sequence of elements within an array.
+    Concept: Array, Divide and Conquer, Dynamic Programming
+    Time Complexity: O(N), Runtime 1ms
+    Space Complexity: O(1), Memory 57.02MB
+*/
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int max = nums[0];
+        int sum = nums[0];
+        for(int i=1; i<nums.length; i++){
+            sum = Math.max(nums[i], nums[i]+sum);
+            max = Math.max(max, sum);
+        }
+        return max;
+    }
+}

product-of-array-except-self/minji-go.java

@@ -0,0 +1,24 @@
+/*
+    Problem: https://leetcode.com/problems/product-of-array-except-self/
+    Description: return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].
+    Concept: Array, Prefix Sum
+    Time Complexity: O(N), Runtime 5ms
+    Space Complexity: O(N), Memory 54.6MB - O(1) except the output array
+*/
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int[] answer = new int[nums.length];
+        Arrays.fill(answer, 1);
+
+        int prefixProduct = 1;
+        int suffixProduct = 1;
+        for(int i=1; i<nums.length; i++){
+            prefixProduct = prefixProduct * nums[i-1];
+            suffixProduct = suffixProduct * nums[nums.length-i];
+            answer[i] *= prefixProduct;
+            answer[nums.length-i-1] *= suffixProduct;
+        }
+
+        return answer;
+    }
+}

reverse-bits/minji-go.java

@@ -0,0 +1,19 @@
+/*
+    Problem: https://leetcode.com/problems/reverse-bits/
+    Description: Reverse bits of a given 32 bits unsigned integer
+    Topics: Divide and Conquer, Bit Manipulation
+    Time Complexity: O(1), Runtime 1ms
+    Space Complexity: O(1), Memory 41.72MB
+*/
+public class Solution {
+    public int reverseBits(int n) {
+        long unsignedNum = n > 0 ? n : n + 2 * (long) Math.pow(2,31); //= Integer.toUnsignedLong()
+
+        int reversedNum = 0;
+        for(int i=31; i>=0; i--){
+            if(unsignedNum % 2 == 1) reversedNum += (long) Math.pow(2,i); //= (1<<i)
+            unsignedNum/=2;
+        }
+        return reversedNum;
+    }
+}

two-sum/minji-go.java

@@ -0,0 +1,21 @@
+/*
+    Problem: https://leetcode.com/problems/two-sum/
+    Description: return indices of the two numbers such that they add up to target. not use the same element twice.
+    Topics: Array, Hash Table
+    Time Complexity: O(N), Runtime 2ms
+    Space Complexity: O(N), Memory 45.1MB
+*/
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> numIndex = new HashMap<>();
+        for(int secondIndex=0; secondIndex<nums.length; secondIndex++){
+            if(numIndex.containsKey(target-nums[secondIndex])){
+                int firstIndex = numIndex.get(target-nums[secondIndex]);
+                return new int[]{firstIndex, secondIndex};
+            } else {
+                numIndex.put(nums[secondIndex], secondIndex);
+            }
+        }
+        return new int[]{};
+    }
+}