Merge pull request #165 from nhistory/week10

[Sehwan] Week10 solution with JavaScript

graph-valid-tree/nhistory.js

@@ -0,0 +1,46 @@
+class Solution {
+  /**
+   * @param {number} n
+   * @param {number[][]} edges
+   * @returns {boolean}
+   */
+  validTree(n, edges) {
+    // A valid tree must have exactly n - 1 edges
+    if (edges.length !== n - 1) {
+      return false;
+    }
+
+    // Initialize the adjacency list
+    let graph = [];
+    for (let i = 0; i < n; i++) {
+      graph.push([]);
+    }
+
+    // Populate the adjacency list with edges
+    for (let [node, neighbor] of edges) {
+      graph[node].push(neighbor);
+      graph[neighbor].push(node);
+    }
+
+    let visited = new Set();
+
+    // Depth-First Search (DFS) to explore the graph
+    function dfs(node) {
+      visited.add(node);
+      for (let neighbor of graph[node]) {
+        if (!visited.has(neighbor)) {
+          dfs(neighbor);
+        }
+      }
+    }
+
+    // Start DFS from node 0
+    dfs(0);
+
+    // Check if all nodes were visited
+    return visited.size === n;
+  }
+}
+
+// TC: O(n)
+// SC: O(n)

house-robber-ii/nhistory.js

@@ -0,0 +1,20 @@
+var rob = function (nums) {
+  // edge case
+  if (nums.length === 1) return nums[0];
+
+  const dp = (start, end) => {
+    let prev = 0,
+      curr = 0;
+    for (let i = start; i < end; i++) {
+      let temp = curr;
+      curr = Math.max(nums[i] + prev, curr);
+      prev = temp;
+    }
+    return curr;
+  };
+
+  return Math.max(dp(0, nums.length - 1), dp(1, nums.length));
+};
+
+// TC: O(n)
+// SC: O(1)

house-robber/nhistory.js

@@ -0,0 +1,16 @@
+var rob = function (nums) {
+  // dynamic programming
+  let prev = 0,
+    curr = 0;
+
+  for (let num of nums) {
+    let temp = curr;
+    curr = Math.max(num + prev, curr);
+    prev = temp;
+  }
+
+  return curr;
+};
+
+// TC: O(n)
+// SC: O(1)

longest-palindromic-substring/nhistory.js

@@ -0,0 +1,32 @@
+var longestPalindrome = function (s) {
+  let maxStart = 0,
+    maxEnd = 0;
+
+  for (let i = 0; i < s.length; i++) {
+    let start = i,
+      end = i;
+    while (start >= 0 && end < s.length && s[start] === s[end]) {
+      if (end - start > maxEnd - maxStart) {
+        maxStart = start;
+        maxEnd = end;
+      }
+      start--;
+      end++;
+    }
+
+    (start = i), (end = i + 1);
+    while (start >= 0 && end < s.length && s[start] === s[end]) {
+      if (end - start > maxEnd - maxStart) {
+        maxStart = start;
+        maxEnd = end;
+      }
+      start--;
+      end++;
+    }
+  }
+
+  return s.slice(maxStart, maxEnd + 1);
+};
+
+// TC: O(n^2)
+// SC: O(1)

number-of-connected-components-in-an-undirected-graph/nhistory.js

@@ -0,0 +1,38 @@
+export class Solution {
+  /**
+   * @param n: the number of vertices
+   * @param edges: the edges of undirected graph
+   * @return: the number of connected components
+   */
+  countComponents(n, edges) {
+    // write your code here
+    const graph = Array.from({ length: n }, () => []);
+
+    for (const [node, neighbor] of edges) {
+      graph[node].push(neighbor);
+      graph[neighbor].push(node);
+    }
+
+    let visited = new Set();
+    let count = 0;
+
+    const dfs = (node) => {
+      visited.add(node);
+      for (const nei of graph[node]) {
+        if (!visited.has(nei)) dfs(nei);
+      }
+    };
+
+    for (let node = 0; node < n; node++) {
+      if (!visited.has(node)) {
+        count++;
+        dfs(node);
+      }
+    }
+    return count;
+  }
+}
+
+// n: number of node | e: number of edge
+// TC: O(n+e)
+// SC: O(n+e)