[oh-chaeyeon] 24.11.19 (#99)

* 201 / Binary Tree Level Order Traversal / Medium / 21m 49s

* 572 / Subtree Of Another Tree / Easy / 25m 09s

* 213 / House Robber II / Medium / 20m 31s

* 207 / Course Schedule / Medium / 21m 49s

* 150 / Evaluate Reverse Polish Notation / Medium / 14m 58s

Author: oh-chaeyeon

oh-chaeyeon/150_Evaluate_Reverse_Polish_Notation.js

@@ -0,0 +1,38 @@
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+var evalRPN = function (tokens) {
+  const stack = [];
+  for (const token of tokens) {
+    if (!isNaN(token)) {
+      stack.push(Number(token));
+    } else {
+      const b = stack.pop();
+      const a = stack.pop();
+
+      let result;
+      switch (token) {
+        case "+":
+          result = a + b;
+          break;
+        case "-":
+          result = a - b;
+          break;
+        case "*":
+          result = a * b;
+          break;
+        case "/":
+          result = Math.trunc(a / b);
+          break;
+      }
+      stack.push(result);
+    }
+  }
+
+  return stack.pop();
+};
+
+// Time taken : 14m 58s
+// Runtime : 2ms
+// Memory : 51.92MB

oh-chaeyeon/201_Binary_Tree_Level_Order_Traversal.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function (root) {
+  const result = [];
+  const Tree = (node, level) => {
+    if (!node) return;
+
+    if (result.length === level) {
+      result.push([]);
+    }
+
+    result[level].push(node.val);
+    Tree(node.left, level + 1);
+    Tree(node.right, level + 1);
+  };
+
+  Tree(root, 0);
+  return result;
+};
+
+// Time taken : 21m 49s
+// Runtime : 1ms
+// Memory : 55.59MB

oh-chaeyeon/207_Course_Schedule.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const graph = Array.from({ length: numCourses }, () => []);
+  for (const [a, b] of prerequisites) {
+    graph[b].push(a);
+  }
+
+  const visited = new Array(numCourses).fill(0);
+
+  const dfs = (course) => {
+    if (visited[course] === 1) return false;
+    if (visited[course] === 2) return true;
+
+    visited[course] = 1;
+    for (const nextCourse of graph[course]) {
+      if (!dfs(nextCourse)) return false;
+    }
+    visited[course] = 2;
+    return true;
+  };
+
+  for (let i = 0; i < numCourses; i++) {
+    if (!dfs(i)) return false;
+  }
+
+  return true;
+};
+
+// Time taken : 21m 49s
+// Runtime : 14ms
+// Memory : 55.35MB

oh-chaeyeon/213_House_Robber_II.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  const n = nums.length;
+
+  if (n === 0) return 0;
+  if (n === 1) return nums[0];
+
+  const FindMoney = (houses) => {
+    let one = 0,
+      two = 0;
+    for (let money of houses) {
+      const temp = one;
+      one = Math.max(one, two + money);
+      two = temp;
+    }
+    return one;
+  };
+
+  return Math.max(FindMoney(nums.slice(0, n - 1)), FindMoney(nums.slice(1)));
+};
+
+// Time taken : 20m 31s
+// Runtime : 0ms
+// Memory : 48.34MB

oh-chaeyeon/572_Subtree_Of_Another_Tree.js

@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} subRoot
+ * @return {boolean}
+ */
+var isSubtree = function (root, subRoot) {
+  if (!subRoot) return true;
+  if (!root) return false;
+
+  if (root.val === subRoot.val) {
+    const checkSame = (node1, node2) => {
+      if (!node1 && !node2) return true;
+      if (!node1 || !node2) return false;
+      if (node1.val !== node2.val) return false;
+
+      return (
+        checkSame(node1.left, node2.left) && checkSame(node1.right, node2.right)
+      );
+    };
+
+    if (checkSame(root, subRoot)) {
+      return true;
+    }
+  }
+
+  return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
+};
+
+// Time taken : 25m 09s
+// Runtime : 6ms
+// Memory : 55.18MB