[yhkee0404] WEEK 10 solutions

course-schedule/yhkee0404.swift

@@ -0,0 +1,32 @@
+class Solution {
+    func canFinish(_ numCourses: Int, _ prerequisites: [[Int]]) -> Bool {
+        var adj: [[Int]] = Array(repeating: [], count: numCourses)
+        for ab in prerequisites {
+            adj[ab[0]].append(ab[1])
+        }
+        var visited = Array(repeating: 0, count: numCourses)
+        var stack = Array(0..<numCourses)
+        while !stack.isEmpty {
+            let u = stack.last!
+            if visited[u] == 2 {
+                stack.removeLast()
+                continue
+            } else if visited[u] == 1 {
+                visited[u] = 2
+                stack.removeLast()
+                continue
+            }
+            visited[u] = 1
+            for v in adj[u] {
+                if visited[v] == 1 {
+                    return false
+                }
+                if visited[v] == 2 {
+                    continue
+                }
+                stack.append(v)
+            }
+        }
+        return true
+    }
+}

invert-binary-tree/yhkee0404.rs

@@ -0,0 +1,31 @@
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn invert_tree(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+        if let Some(u) = &root {
+            let mut u = u.borrow_mut();
+            let v = u.left.clone();
+            u.left = Self::invert_tree(u.right.clone());
+            u.right = Self::invert_tree(v);
+        }
+        root
+    }
+}

jump-game/yhkee0404.dart

@@ -0,0 +1,11 @@
+class Solution {
+  bool canJump(List<int> nums) {
+    for (int i = 0, j = 0; j < nums.length - 1; i++) {
+        if (j < i) {
+            return false;
+        }
+        j = max(i + nums[i], j);
+    }
+    return true;
+  }
+}

merge-k-sorted-lists/yhkee0404.go

@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+type Heap []*ListNode
+
+func (pq Heap) Len() int {return len(pq)}
+func (pq Heap) Less(i, j int) bool {
+    return pq[i].Val < pq[j].Val
+}
+func (pq Heap) Swap(i, j int) {pq[i], pq[j] = pq[j], pq[i]}
+func (pq *Heap) Push(x any) {*pq = append(*pq, x.(*ListNode))}
+func (pq *Heap) Pop() any {
+    x := (*pq)[len(*pq) - 1]
+    *pq = (*pq)[:len(*pq) - 1]
+    return x
+}
+
+func mergeKLists(lists []*ListNode) *ListNode {
+    h := Heap{}
+    for _, l := range lists {
+        if l != nil {
+            h = append(h, l)
+        }
+    }
+    heap.Init(&h)
+    ans := ListNode{}
+    u := &ans
+    for len(h) > 0 { // T(n) = S(n) = O(nlogn)
+        u.Next = heap.Pop(&h).(*ListNode)
+        u = u.Next
+        if u.Next != nil {
+            heap.Push(&h, u.Next)
+        }
+    }
+    return ans.Next
+}

search-in-rotated-sorted-array/yhkee0404.scala

@@ -0,0 +1,26 @@
+object Solution {
+    def search(nums: Array[Int], target: Int): Int = {
+        var l = 0
+        var r = nums.length - 1
+        while (l != r) {
+            val mid = r - ((r - l) >> 1)
+            if (nums(mid) > nums(0)) {
+                l = mid
+            } else {
+                r = mid - 1
+            }
+        }
+        l = r + 1
+        r = l + nums.length
+        while (l != r) {
+            val mid = l + ((r - l) >> 1)
+            if (nums(mid % nums.length) < target) {
+                l = mid + 1
+            } else {
+                r = mid
+            }
+        }
+        l %= nums.length
+        if (nums(l) == target) l else -1
+    }
+}