[byteho0n] - Week 10

course-schedule/ekgns33.java

@@ -0,0 +1,44 @@
+/*
+*
+* solution : topological sort
+* tc : O(E + V)
+* sc : O(E + V)
+*
+* */
+class Solution {
+  public boolean canFinish(int numCourses, int[][] prerequisites) {
+    List<Integer>[] adj = new ArrayList[numCourses];
+    for(int i = 0 ; i < numCourses; i++) {
+      adj[i] = new ArrayList<>();
+    }
+    boolean[] v = new boolean[numCourses];
+    int[] indeg = new int[numCourses];
+    for(int[] pre : prerequisites) {
+      int src = pre[0];
+      int dst = pre[1];
+      adj[src].add(dst);
+      indeg[dst]++;
+    }
+    Queue<Integer> q = new LinkedList<>();
+    for(int i = 0; i < numCourses; i ++) {
+      if(indeg[i] == 0) {
+        q.add(i);
+        v[i] = true;
+      }
+    }
+    int cnt= 0;
+    while(!q.isEmpty()) {
+      int curNode = q.poll();
+      cnt++;
+      for(int dst : adj[curNode]) {
+        indeg[dst]--;
+        if(indeg[dst] ==0 && !v[dst]) {
+          q.add(dst);
+        }
+      }
+    }
+
+    return cnt == numCourses;
+
+  }
+}

invert-binary-tree/ekgns33.java

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public TreeNode invertTree(TreeNode root) {
+    if(root == null) return null;
+    TreeNode left = invertTree(root.left);
+    TreeNode right = invertTree(root.right);
+    root.right = left;
+    root.left =right;
+    return root;
+  }
+}

jump-game/ekgns33.java

@@ -0,0 +1,20 @@
+/*
+* solution : dp
+* tc : O(n)
+* sc : O(n)
+*
+* let dp[i] farthest point available to reach
+*
+* */
+class Solution {
+  public boolean canJump(int[] nums) {
+    int[] dp = new int[nums.length];
+    dp[0] = nums[0];
+    for(int i = 1; i < nums.length; i++) {
+      if(dp[i-1] >= i) {
+        dp[i] = Math.max(nums[i] + i, dp[i-1]);
+      }
+    }
+    return dp[dp.length-1] >= dp.length-1;
+  }
+}

merge-k-sorted-lists/ekgns33.java

@@ -0,0 +1,86 @@
+/**
+ * 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 ListNode mergeKLists(ListNode[] lists) {
+    List<ListNode> list = new LinkedList<>();
+    for(ListNode l : lists) {
+      list.add(l);
+    }
+    return divide(list);
+
+  }
+  public ListNode divide(List<ListNode> list) {
+    //두개씩 나누기. 두개 안되면 그냥 리스트에 넣고 리턴
+    int n = list.size();
+    ListNode sum1;
+    ListNode sum2;
+    if(list.size() <= 2) {
+      return merge(list);
+    }
+
+    int mid =  n / 2;
+    List<ListNode> upper = new LinkedList<>();
+    List<ListNode> last = new LinkedList<>();
+
+
+    for(int i = 0; i < mid; i ++) {
+      upper.add(list.get(i));
+
+    }
+    sum1 = divide(upper);
+
+
+    for(int i = mid; i < n; i++) {
+      last.add(list.get(i));
+    }
+    sum2 = divide(last);
+
+    List<ListNode> m = new LinkedList<>();
+    m.add(sum1);
+    m.add(sum2);
+
+
+    return merge(m);
+
+
+  }
+  public ListNode merge(List<ListNode> list) {
+    //edge
+    if(list.size()==0) return null;
+    if(list.size() == 1) return list.get(0);
+
+    ListNode n1 = list.get(0);
+    ListNode n2 = list.get(1);
+    // System.out.println(n1.val + " : " + n2.val);
+
+    ListNode res = new ListNode(0);
+    ListNode head = res;
+
+    while(n1 != null && n2 != null) {
+      if(n1.val < n2.val){
+        res.next = n1;
+        res = res.next;
+        n1 = n1.next;
+      } else {
+        res.next = n2;
+        res = res.next;
+        n2 = n2.next;
+      }
+
+    }
+    if(n1 == null) res.next = n2;
+    if(n2 == null) res.next = n1;
+    return head.next;
+
+
+
+  }
+}

search-in-rotated-sorted-array/ekgns33.java

@@ -0,0 +1,56 @@
+/**
+
+ input : rotated array
+ output : index of target else -1
+
+ 4 5 6 7 0 1 2
+ target = 6
+ return 2
+
+ solution1) brute force
+ return index after loop
+ tc : O(n)
+ sc : O(1)
+
+ solution2)
+ separte array into 2 parts to make sure each part is sorted.
+ find the rotated point, binary search for target
+ O(logn) + O(logn)
+
+ tc : O(logn)
+ sc : O(1)
+ */
+class Solution {
+  public int search(int[] nums, int target) {
+    int l = 0;
+    int r = nums.length - 1;
+    while(l < r) {
+      int mid = (r - l) / 2 +l;
+      if(nums[mid] <= nums[r]) {
+        r = mid;
+      } else {
+        l = mid + 1;
+      }
+    }
+    // determine which part
+    int start = 0;
+    int end = nums.length - 1;
+    if(nums[start] <= target && nums[Math.max(0, l-1)] >= target) {
+      end = Math.max(0, l - 1);
+    } else if (nums[l] <= target && nums[end] >= target){
+      start = l;
+    }
+
+    while(start <= end) {
+      int mid = (end - start) / 2 + start;
+      if(nums[mid] == target) {
+        return mid;
+      } else if (nums[mid] < target) {
+        start = mid + 1;
+      } else {
+        end = mid - 1;
+      }
+    }
+    return -1;
+  }
+}