[gitsunmin] Week 6 Solutions

container-with-most-water/gitsunmin.ts

@@ -0,0 +1,15 @@
+/**
+ * https://leetcode.com/problems/container-with-most-water/
+ * time complexity : O(n)
+ * space complexity : O(1)
+ */
+export function maxArea(height: number[]): number {
+    let s = 0, e = height.length - 1, max = 0;
+
+    while (s < e) {
+        max = Math.max((e - s) * Math.min(height[s], height[e]), max);
+        if (height[s] < height[e]) s++;
+        else e--;
+    }
+    return max;
+};

design-add-and-search-words-data-structure/gitsunmin.ts

@@ -0,0 +1,60 @@
+/**
+ * https://leetcode.com/problems/design-add-and-search-words-data-structure
+ * n: The total number of words stored in the Trie.
+ * m: The average length of each word.
+ * 
+ * time complexity:
+ * - addWord: O(m)
+ * - search: O(26^m) in the worst case (with multiple wildcards) to O(m) in general cases.
+ * space complexity: 
+ * - addWord: O(n * m)
+ * - search: O(n * m)
+ */
+class TrieNode {
+    children: Map<string, TrieNode>;
+    isEnd: boolean;
+
+    constructor() {
+        this.children = new Map();
+        this.isEnd = false;
+    }
+}
+
+export class WordDictionary {
+    private root: TrieNode;
+
+    constructor() {
+        this.root = new TrieNode();
+    }
+
+    addWord(word: string): void {
+        let node = this.root;
+
+        for (const char of word) {
+            if (!node.children.has(char)) node.children.set(char, new TrieNode());
+
+            node = node.children.get(char)!;
+        }
+        node.isEnd = true;
+    }
+
+    search(word: string): boolean {
+        return this.searchInNode(word, 0, this.root);
+    }
+
+    private searchInNode(word: string, index: number, node: TrieNode): boolean {
+        if (index === word.length) return node.isEnd;
+
+        const char = word[index];
+
+        if (char === '.') {
+            for (const child of node.children.values()) {
+                if (this.searchInNode(word, index + 1, child)) return true;
+            }
+            return false;
+        } else {
+            if (!node.children.has(char)) return false;
+            return this.searchInNode(word, index + 1, node.children.get(char)!);
+        }
+    }
+}

longest-increasing-subsequence/gitsunmin.ts

@@ -0,0 +1,21 @@
+/**
+ * https://leetcode.com/problems/longest-increasing-subsequence
+ * time complexity : O(n²)
+ * space complexity : O(n)
+ */
+function lengthOfLIS(nums: number[]): number {
+    const [head] = nums;
+    const basket = [head];
+
+    for (let i = 1; i < nums.length; i++) {
+        const current = nums[i];
+        let j = 0;
+
+        while (j < basket.length && basket[j] < current) j++;
+
+        if (j === basket.length) basket.push(current);
+        else basket[j] = current;
+    }
+
+    return basket.length;
+};

spiral-matrix/gitsunmin.ts

@@ -0,0 +1,32 @@
+/**
+ * https://leetcode.com/problems/spiral-matrix/
+ * time complexity : O(m * n)
+ * space complexity : O(m * n)
+ */
+
+function spiralOrder(matrix: number[][]): number[] {
+    let [left, right] = [0, matrix[0].length - 1];
+    let [top, bottom] = [0, matrix.length - 1];
+
+    const output = [] as number[];
+
+    while (top <= bottom && left <= right) {
+        for (let i = left; i <= right; i++) output.push(matrix[top][i]);
+        top++;
+
+        for (let i = top; i <= bottom; i++) output.push(matrix[i][right]);
+        right--;
+
+        if (top <= bottom) {
+            for (let i = right; i >= left; i--) output.push(matrix[bottom][i]);
+            bottom--;
+        }
+
+        if (left <= right) {
+            for (let i = bottom; i >= top; i--) output.push(matrix[i][left]);
+            left++;
+        }
+    }
+
+    return output;
+};

valid-parentheses/gitsunmin.ts

@@ -0,0 +1,25 @@
+/**
+ * https://leetcode.com/problems/valid-parentheses/
+ * time complexity : O(n)
+ * space complexity : O(n)
+ */
+
+type OpeningBracket = '(' | '[' | '{';
+type ClosingBracket = ')' | ']' | '}';
+
+const isEmpty = (stack: OpeningBracket[]): boolean => stack.length === 0;
+
+function isValid(s: string): boolean {
+    const m = new Map<string, ClosingBracket>([
+        ['(', ')'],
+        ['[', ']'],
+        ['{', '}']
+    ]);
+    const stack: OpeningBracket[] = [];
+
+    for (const c of s) {
+        if (m.has(c)) stack.push(c as OpeningBracket);
+        else if (isEmpty(stack) || c !== m.get(stack.pop() as OpeningBracket)) return false;
+    }
+    return isEmpty(stack);
+};