[hsskey] Week 15 Solutions

alien-dictionary/hsskey.js

@@ -0,0 +1,55 @@
+export class Solution {
+    /**
+     * @param {string[]} words
+     * @return {string}
+     */
+    alienOrder(words) {
+        const adj = new Map();
+        for (const word of words) {
+            for (const char of word) {
+                if (!adj.has(char)) {
+                    adj.set(char, new Set());
+                }
+            }
+        }
+
+        for (let i = 0; i < words.length - 1; i++) {
+            const w1 = words[i];
+            const w2 = words[i + 1];
+            const minLen = Math.min(w1.length, w2.length);
+
+            if (w1.length > w2.length && w1.slice(0, minLen) === w2.slice(0, minLen)) {
+                return "";
+            }
+
+            for (let j = 0; j < minLen; j++) {
+                if (w1[j] !== w2[j]) {
+                    adj.get(w1[j]).add(w2[j]);
+                    break;
+                }
+            }
+        }
+
+        const visit = {}; // false: visited, true: current path (cycle detection)
+        const res = [];
+
+        const dfs = (c) => {
+            if (c in visit) return visit[c];
+
+            visit[c] = true;
+            for (const nei of adj.get(c)) {
+                if (dfs(nei)) return true;
+            }
+            visit[c] = false;
+            res.push(c);
+            return false;
+        };
+
+        for (const c of adj.keys()) {
+            if (dfs(c)) return "";
+        }
+
+        return res.reverse().join('');
+    }
+}
+

construct-binary-tree-from-preorder-and-inorder-traversal/hsskey.js

@@ -0,0 +1,28 @@
+/**
+ * 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 {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+var buildTree = function(preorder, inorder) {
+    if (!preorder.length || !inorder.length) {
+        return null;
+    }
+
+    const root = new TreeNode(preorder[0]);
+    const mid = inorder.indexOf(preorder[0]);
+
+    root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
+    root.right = buildTree(preorder.slice(mid + 1), inorder.slice(mid + 1));
+
+    return root;
+};
+

longest-palindromic-substring/hsskey.js

@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var longestPalindrome = function(s) {
+    let res = "";
+    let resLen = 0;
+
+    for (let i = 0; i < s.length; i++) {
+        // Odd length
+        let l = i,
+            r = i;
+        while (l >= 0 && r < s.length && s[l] === s[r]) {
+            if (r - l + 1 > resLen) {
+                res = s.slice(l, r + 1);
+                resLen = r - l + 1;
+            }
+            l--;
+            r++;
+        }
+
+        // Even length
+        l = i, r = i + 1;
+        while (l >= 0 && r < s.length && s[l] === s[r]) {
+            if (r - l + 1 > resLen) {
+                res = s.slice(l, r + 1);
+                resLen = r - l + 1;
+            }
+            l--;
+            r++;
+        }
+    }
+
+    return res;
+};
+

rotate-image/hsskey.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var rotate = function(matrix) {
+    let l = 0;
+    let r = matrix.length - 1;
+
+    while (l < r) {
+        for (let i = 0; i < r - l; i++) {
+            let top = l;
+            let bottom = r;
+
+            // save the top-left
+            let topLeft = matrix[top][l + i];
+
+            // move bottom-left into top-left
+            matrix[top][l + i] = matrix[bottom - i][l];
+
+            // move bottom-right into bottom-left
+            matrix[bottom - i][l] = matrix[bottom][r - i];
+
+            // move top-right into bottom-right
+            matrix[bottom][r - i] = matrix[top + i][r];
+
+            // move top-left into top-right
+            matrix[top + i][r] = topLeft;
+        }
+        r--;
+        l++;
+    }
+};
+

subtree-of-another-tree/hsskey.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} s
+ * @param {TreeNode} t
+ * @return {boolean}
+ */
+var isSubtree = function(s, t) {
+    if (!t) return true;
+    if (!s) return false;
+
+    if (sameTree(s, t)) {
+        return true;
+    }
+    return isSubtree(s.left, t) || isSubtree(s.right, t);
+};
+
+/**
+ * @param {TreeNode} s
+ * @param {TreeNode} t
+ * @return {boolean}
+ */
+var sameTree = function(s, t) {
+    if (!s && !t) return true;
+
+    if (s && t && s.val === t.val) {
+        return sameTree(s.left, t.left) && sameTree(s.right, t.right);
+    }
+
+    return false;
+};
+