[chjung99] WEEK 09 solutions

clone-graph/chjung99.java

@@ -0,0 +1,49 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    public Node cloneGraph(Node node) {
+        if (node == null) return node;
+        return deepCopy(node);
+    }
+
+    public Node deepCopy(Node node) {
+        Deque<Node> deque = new ArrayDeque<>();
+        Node root = new Node(node.val, new ArrayList<>());
+        Map<Integer, Node> visit = new HashMap<>();
+
+        visit.put(1, root);
+        deque.add(node);
+
+        while (!deque.isEmpty()) {
+            Node cur = deque.poll();
+            for (Node next: cur.neighbors) {
+                if (!visit.containsKey(next.val)){
+                    visit.put(next.val, new Node(next.val, new ArrayList<>()));
+                    deque.add(next);
+                }
+                visit.get(cur.val).neighbors.add(visit.get(next.val));
+            }
+        }
+        return root;
+    }
+}
+
+

find-minimum-in-rotated-sorted-array/chjung99.java

@@ -0,0 +1,23 @@
+class Solution {
+    public int findMin(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        int mid = (left + right) / 2;
+        while (left + 1 < right){
+            mid = (left + right) / 2;
+            if (nums[mid] > nums[right]) {
+                left = mid;
+            }
+            if (nums[mid] < nums[right]) {
+                right = mid;
+            }
+        }
+        mid = (left + right) / 2;
+        if (nums[mid] > nums[right]) return nums[right];
+        else {
+            return nums[mid];
+        }
+    }
+}
+
+

maximum-product-subarray/chjung99.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        int n = nums.length;
+        int[] dpMax = new int[n];
+        int[] dpMin = new int[n];
+
+        dpMax[0] = nums[0];
+        dpMin[0] = nums[0];
+        for (int i = 1; i < n; i++){
+            dpMax[i] = Math.max(Math.max(dpMax[i-1]*nums[i], nums[i]), dpMin[i-1]*nums[i]);
+            dpMin[i] = Math.min(Math.min(dpMin[i-1]*nums[i], nums[i]), dpMax[i-1]*nums[i]);
+        }
+        return findMax(dpMax);
+    }
+
+    public int findMax(int[] dp) {
+        int answer = dp[0];
+        for (int i = 0; i < dp.length; i++) {
+            answer = Math.max(dp[i], answer);
+        }
+        return answer;
+    }
+}
+

reorder-list/chjung99.java

@@ -0,0 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public void reorderList(ListNode head) {
+        Map<Integer, ListNode> order = new HashMap<>();
+        ListNode start = head;
+        int n = 0;
+
+        while (start != null) {
+            order.put(n, start);
+            start = start.next;
+            n++;
+        }
+
+        ListNode cur = head;
+        List<Integer> newOrder = generateOrder(n);
+
+        for (int i = 0; i < n; i++) {
+            int idx = newOrder.get(i);
+            cur = order.get(idx);
+            if (i + 1 < n) {
+                cur.next = order.get(newOrder.get(i+1));
+            } else {
+                cur.next = null;
+            }
+            cur = cur.next;
+        }
+    }
+    public List<Integer> generateOrder(int n) {
+        List<Integer> reorder = new ArrayList<>();
+        int[] asc = new int[n];
+        int[] desc = new int[n];
+
+        for (int i = 0; i < n; i++) {
+            asc[i] = i;
+            desc[i] = n - 1 - i;
+        }
+
+        for (int i = 0; i< n; i++) {
+            if (i % 2 == 0) {
+                reorder.add(asc[i/2]);
+            } else {
+                reorder.add(desc[i/2]);
+            }
+        }
+        return reorder;
+    }
+}
+

word-break/chjung99.java

@@ -0,0 +1,19 @@
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        Set<String> wordSet = new HashSet<>(wordDict);
+        int n = s.length();
+        boolean[] dp = new boolean[n];
+        for (int i = 0; i < n; i++) {
+            dp[i] = wordSet.contains(s.substring(0, i+1));
+            for (int j = 0; j < i; j++) {
+                if (dp[j] && wordSet.contains(s.substring(j+1, i+1))){
+                    dp[i] = true;
+                }
+            }
+        }
+
+        return dp[n-1];
+    }
+}
+
+