Solutions

Author: trinhminhtriet

solutions/0100-0199/0133.clone-graph/Solution.js

@@ -0,0 +1,30 @@
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+    const g = new Map();
+    const dfs = node => {
+        if (!node) {
+            return null;
+        }
+        if (g.has(node)) {
+            return g.get(node);
+        }
+        const cloned = new _Node(node.val);
+        g.set(node, cloned);
+        for (const nxt of node.neighbors) {
+            cloned.neighbors.push(dfs(nxt));
+        }
+        return cloned;
+    };
+    return dfs(node);
+};

solutions/0200-0299/0206.reverse-linked-list/Solution2.cs

@@ -0,0 +1,22 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode ans = ReverseList(head.next);
+        head.next.next = head;
+        head.next = null;
+        return ans;
+    }
+}

solutions/0200-0299/0235.lowest-common-ancestor-of-a-binary-search-tree/Solution.cs

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val < Math.Min(p.val, q.val)) {
+                root = root.right;
+            } else if (root.val > Math.Max(p.val, q.val)) {
+                root = root.left;
+            } else {
+                return root;
+            }
+        }
+    }
+}

solutions/0200-0299/0235.lowest-common-ancestor-of-a-binary-search-tree/Solution2.cs

@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val < Math.Min(p.val, q.val)) {
+            return LowestCommonAncestor(root.right, p, q);
+        }
+        if (root.val > Math.Max(p.val, q.val)) {
+            return LowestCommonAncestor(root.left, p, q);
+        }
+        return root;
+    }
+}

solutions/0200-0299/0253.meeting-rooms-ii/Solution.ts

@@ -0,0 +1,14 @@
+function minMeetingRooms(intervals: number[][]): number {
+    const m = Math.max(...intervals.map(([_, r]) => r));
+    const d: number[] = Array(m + 1).fill(0);
+    for (const [l, r] of intervals) {
+        d[l]++;
+        d[r]--;
+    }
+    let [ans, s] = [0, 0];
+    for (const v of d) {
+        s += v;
+        ans = Math.max(ans, s);
+    }
+    return ans;
+}

solutions/0200-0299/0253.meeting-rooms-ii/Solution2.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int minMeetingRooms(vector<vector<int>>& intervals) {
+        map<int, int> d;
+        for (const auto& e : intervals) {
+            d[e[0]]++;
+            d[e[1]]--;
+        }
+        int ans = 0, s = 0;
+        for (auto& [_, v] : d) {
+            s += v;
+            ans = max(ans, s);
+        }
+        return ans;
+    }
+};

solutions/0200-0299/0253.meeting-rooms-ii/Solution2.go

@@ -0,0 +1,20 @@
+func minMeetingRooms(intervals [][]int) (ans int) {
+	d := make(map[int]int)
+	for _, e := range intervals {
+		d[e[0]]++
+		d[e[1]]--
+	}
+
+	keys := make([]int, 0, len(d))
+	for k := range d {
+		keys = append(keys, k)
+	}
+	sort.Ints(keys)
+
+	s := 0
+	for _, k := range keys {
+		s += d[k]
+		ans = max(ans, s)
+	}
+	return
+}

solutions/0200-0299/0253.meeting-rooms-ii/Solution2.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int minMeetingRooms(int[][] intervals) {
+        Map<Integer, Integer> d = new TreeMap<>();
+        for (var e : intervals) {
+            d.merge(e[0], 1, Integer::sum);
+            d.merge(e[1], -1, Integer::sum);
+        }
+        int ans = 0, s = 0;
+        for (var e : d.values()) {
+            s += e;
+            ans = Math.max(ans, s);
+        }
+        return ans;
+    }
+}

solutions/0200-0299/0253.meeting-rooms-ii/Solution2.py

@@ -0,0 +1,11 @@
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        d = defaultdict(int)
+        for l, r in intervals:
+            d[l] += 1
+            d[r] -= 1
+        ans = s = 0
+        for _, v in sorted(d.items()):
+            s += v
+            ans = max(ans, s)
+        return ans

solutions/0200-0299/0253.meeting-rooms-ii/Solution2.rs

@@ -0,0 +1,24 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_meeting_rooms(intervals: Vec<Vec<i32>>) -> i32 {
+        let mut d: HashMap<i32, i32> = HashMap::new();
+        for interval in intervals {
+            let (l, r) = (interval[0], interval[1]);
+            *d.entry(l).or_insert(0) += 1;
+            *d.entry(r).or_insert(0) -= 1;
+        }
+
+        let mut times: Vec<i32> = d.keys().cloned().collect();
+        times.sort();
+
+        let mut ans = 0;
+        let mut s = 0;
+        for time in times {
+            s += d[&time];
+            ans = ans.max(s);
+        }
+
+        ans
+    }
+}