refactor: js | graph (#560)

Co-authored-by: Mitchell Irvin <[email protected]>

Author: aakhtar3

javascript/127-Word-Ladder.js

@@ -1,34 +1,50 @@
-var ladderLength = function (beginWord, endWord, wordList) {
-    if (!wordList.includes(endWord)) return 0;
-    let patternMap = {};
-    wordList.push(beginWord);
-
-    for (let word of wordList) {
-        for (let x = 0; x < word.length; x++) {
-            const pattern = word.slice(0, x) + '*' + word.slice(x + 1);
-            patternMap[pattern] = patternMap[pattern] || [];
-            patternMap[pattern].push(word);
+/**
+ * https://leetcode.com/problems/word-ladder/
+ * Time O(ROWS * COLS) | Space O(ROWS * COLS)
+ * @param {string} beginWord
+ * @param {string} endWord
+ * @param {string[]} wordList
+ * @return {number}
+ */
+ var ladderLength = function(beginWord, endWord, wordList) {
+    const [ queue, wordSet, seen ] = [ new Queue([[ beginWord, 1 ]]), new Set(wordList), new Set([ beginWord ]) ];
+
+    return bfs(queue, wordSet, seen, endWord);/* Time O(ROWS * COLS) | Space O(ROWS * COLS) */
+};
+
+const bfs = (queue, wordSet, seen, endWord) => {
+    while (!queue.isEmpty()) {
+        for (let i = (queue.size() - 1); 0 <= i; i--) {
+            const [ word, depth ] = queue.dequeue();
+
+            const isTarget = word === endWord
+            if (isTarget) return depth
+
+            transform(queue, wordSet, seen, word, depth)
         }
     }
 
-    let wordCount = 1,
-        queue = [beginWord],
-        visited = [beginWord];
-    while (queue.length) {
-        const levelSize = queue.length;
-        for (let x = 0; x < levelSize; x++) {
-            const word = queue.shift();
-            if (word === endWord) return wordCount;
-            for (let x = 0; x < word.length; x++) {
-                const pattern = word.slice(0, x) + '*' + word.slice(x + 1);
-                for (let nei of patternMap[pattern]) {
-                    if (nei in visited) continue;
-                    visited[nei] = true;
-                    queue.push(nei);
-                }
-            }
+    return 0
+}
+
+const transform = (queue, wordSet, seen, word, depth) => {
+    for (const index in word) {
+        for (const char of 'abcdefghijklmnopqrstuvwxyz') {
+            const neighbor = getNeighbor(word, index, char);
+
+            const hasSeen = !wordSet.has(neighbor) || seen.has(neighbor);
+            if (hasSeen) continue;
+
+            queue.enqueue([ neighbor, (depth + 1) ]);
+            seen.add(neighbor);
         }
-        wordCount += 1;
     }
-    return 0;
-};
+}
+
+const getNeighbor = (word, index, char) => {
+    const neighbor = word.split('');
+
+    neighbor[index] = char;
+
+    return neighbor.join('');
+}

javascript/130-Surrounded-Regions.js

@@ -1,68 +1,123 @@
-//////////////////////////////////////////////////////////////////////////////
-// Depth First Search (DFS)
-// Time: O(m*n)
-// Space: O(m*n)
-// You can implement either Depth First Search (DFS) or Breadth First Search
-// (BFS). The only noticeable impact is the performance cost of the BFS queue
-// is higher than the DFS call stack.
-//////////////////////////////////////////////////////////////////////////////
-
 /**
+ * https://leetcode.com/problems/surrounded-regions/
+ * Time O(ROWS * COLS) | Space O(ROWS * COLS)
  * @param {character[][]} board
  * @return {void} Do not return anything, modify board in-place instead.
  */
-function solve(board) {
-    const rowLen = board.length;
-    const colLen = board[0].length;
-    const lastRow = rowLen - 1;
-    const lastCol = colLen - 1;
-
-    for (let r = 0; r < rowLen; ++r) {
-        markSeen(r, 0);
-        markSeen(r, lastCol);
+ var solve = function solve(board) {
+    searchRows(board);/* Time O(ROWS * COLS) | Space O(ROWS * COLS) */
+    searchCols(board);/* Time O(ROWS * COLS) | Space O(ROWS * COLS) */
+    searchGrid(board);/* Time O(ROWS * COLS) | Space O(ROWS * COLS) */
+}
+
+var searchRows = (board) => {
+    const [ rows, cols ] = [ board.length, board[0].length ];
+
+    for (let row = 0; row < rows; row++) {      /* Time O(ROWS) */
+        dfs(board, row, rows, 0, cols);         /* Space O(ROWS) */
+        dfs(board, row, rows, (cols - 1), cols);/* Space O(ROWS) */
     }
-    for (let c = 1; c < lastCol; ++c) {
-        markSeen(0, c);
-        markSeen(lastRow, c);
+}
+
+var searchCols = (board) => {
+    const [ rows, cols ] = [ board.length, board[0].length ];
+
+    for (let col = 1; col < (cols - 1); col++) {/* Time O(COLS) */
+        dfs(board, 0, rows, col, cols);         /* Space O(COLS) */
+        dfs(board, (rows - 1), rows, col, cols);/* Space O(COLS) */
     }
+}
 
-    for (let r = 0; r < rowLen; ++r) {
-        for (let c = 0; c < colLen; ++c) {
-            switch (board[r][c]) {
-                case 'O':
-                    board[r][c] = 'X';
-                    break;
-                case 'A':
-                    board[r][c] = 'O';
-                    break;
-            }
+var searchGrid = (board) => {
+    const [ rows, cols ] = [ board.length, board[0].length ];
+
+    for (let row = 0; row < rows; row++) {/* Time O(ROWS) */
+        for (let col = 0; col < cols; col++) {/* Time O(COLS) */
+            const isO = board[row][col] === 'O';
+            if (isO) board[row][col] = 'X';
+
+            const isStar = board[row][col] === '*';
+            if (isStar) board[row][col] = 'O';
         }
     }
+}
 
-    /**
-     * @param {number} r
-     * @param {number} c
-     * @return {void}
-     */
-    function markSeen(r, c) {
-        if (!inBounds(r, c) || board[r][c] !== 'O') {
-            return;
-        }
+const dfs = (board, row, rows, col, cols) => {
+    const isBaseCase = board[row][col] !== 'O';
+    if (isBaseCase) return;
+
+    board[row][col] = '*';
+
+    for (const [ _row, _col ] of getNeighbors(row, rows, col, cols)) {
+        dfs(board, _row, rows, _col, cols);/* Time O(HEIGHT) | Space O(HEIGHT) */
+    }
+}
+
+var getNeighbors = (row, rows, col, cols) => [ [0, 1], [0, -1], [1, 0], [-1, 0] ]
+    .map(([ _row, _col ]) => [ (row + _row), (col + _col)])
+    .filter(([ _row, _col ]) => (0 <= _row) && (_row < rows) && (0 <= _col) && (_col < cols))
+
+
+/**
+ * https://leetcode.com/problems/surrounded-regions/
+ * Time O(ROWS * COLS) | Space O(ROWS * COLS)
+ * @param {character[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+ var solve = function solve(board, queue = new Queue([])) {
+    searchRows(board, queue);/* Time O(ROWS + COLS) | Space O(ROWS + COLS) */
+    searchCols(board, queue);/* Time O(ROWS + COLS) | Space O(ROWS + COLS) */
+    bfs(board, queue);       /* Time O(ROWS * COLS) | Space O(ROWS * COLS) */
+    searchGrid(board);       /* Time O(ROWS * COLS) */
+}
 
-        board[r][c] = 'A';
+var searchRows = (board, queue) => {
+    const [ rows, cols ] = [ board.length, board[0].length ]
 
-        markSeen(r - 1, c);
-        markSeen(r + 1, c);
-        markSeen(r, c - 1);
-        markSeen(r, c + 1);
+    for (let row = 0; row < rows; row++) { /* Time O(ROWS) */
+        queue.enqueue([ row, 0 ]);         /* Space O(ROWS) */
+        queue.enqueue([ row, (cols - 1) ]);/* Space O(ROWS) */
     }
+}
+
+var searchCols = (board, queue) => {
+    const [ rows, cols ] = [ board.length, board[0].length ]
 
-    /**
-     * @param {number} r
-     * @param {number} c
-     * @return {boolean}
-     */
-    function inBounds(r, c) {
-        return r >= 0 && c >= 0 && r < rowLen && c < colLen;
+    for (let col = 0; col < (cols - 1); col++) {/* Time O(COLS) */
+        queue.enqueue([ 0, col ]);              /* Space O(COLS) */
+        queue.enqueue([ (rows - 1), col ]);     /* Space O(COLS) */
     }
 }
+
+var bfs = (board, queue) => {
+    const [ rows, cols ] = [ board.length, board[0].length ];
+
+    while (!queue.isEmpty()) {
+        for (let i = (queue.size() - 1); 0 <= i; i--) {/* Time O(WIDTH) */
+            const [ row, col ] = queue.dequeue();
+
+            const isBaseCase = board[row][col] !== 'O';
+            if (isBaseCase) continue;
+
+            board[row][col] = '*';
+
+            for (const [ _row, _col ] of getNeighbors(row, rows, col, cols)) {
+                queue.enqueue([ _row, _col ]);         /* Space O(WIDTH) */
+            }
+        }
+    } 
+}
+
+var searchGrid = (board) => {
+    const [ rows, cols ] = [ board.length, board[0].length ];
+
+    for (let row = 0; row < rows; row++) {/* Time O(ROWS) */
+        for (let col = 0; col < cols; col++) {/* Time O(COLS) */
+            const isO = board[row][col] === 'O';
+            if (isO) board[row][col] = 'X';
+
+            const isStar = board[row][col] === '*';
+            if (isStar) board[row][col] = 'O';
+        }
+    }
+}

javascript/133-Clone-Graph.js

@@ -1,37 +1,68 @@
 /**
- * // Definition for a Node.
- * function Node(val, neighbors) {
- *    this.val = val === undefined ? 0 : val;
- *    this.neighbors = neighbors === undefined ? [] : neighbors;
- * };
+ * https://leetcode.com/problems/clone-graph/
+ * Time O(V + E) | Space O(N)
+ * @param {Node} node
+ * @return {Node}
  */
+var cloneGraph = function(node, seen = new Map()) {
+    const isBaseCase = node === null;
+    if (isBaseCase) return null;
+
+    if (seen.has(node)) return seen.get(node);
+
+    return dfs(node, seen);                              /* Time O(V + E) | Space O(N) */
+}
+
+const dfs = (node, seen) => {
+    const clone = new Node(node.val);
+
+    seen.set(node, clone);                               /*               | Space O(N) */
+
+    for (const neighbor of node.neighbors) {
+        const cloneNeighbor = cloneGraph(neighbor, seen);/* Time O(V + E) | Space O(H) */
+
+        clone.neighbors.push(cloneNeighbor);             /*               | Space O(V + E) */
+    }
+
+    return clone;
+}
 
 /**
+ * https://leetcode.com/problems/clone-graph/
+ * Time O(V + E) | Space O(N)
  * @param {Node} node
  * @return {Node}
  */
-var cloneGraph = function (node) {
-    let visited = {};
+ var cloneGraph = function(node, seen = new Map()) {
+    const isBaseCase = node === null;
+    if (isBaseCase) return null;
 
-    let dfs = (node) => {
-        if (!node) {
-            return node;
-        }
+    seen.set(node, new Node(node.val));                /*               | Space O(N) */
 
-        if (visited[node.val]) {
-            return visited[node.val];
-        }
+    bfs(new Queue([ node ]), seen);                    /* Time O(V + E) | Space O(N) */
+
+    return seen.get(node);
+};
 
-        let copy = new Node(node.val);
+const bfs = (queue, seen) => {
+    while (!queue.isEmpty()) {                         /* Time O(V + E) */
+        for (let i = (queue.size() - 1); 0 <= i; i--) {/* Time O(W) */
+            const node = queue.dequeue();
 
-        visited[node.val] = copy;
+            cloneNeighbors(node, seen, queue);         /* Space O(N) */ 
+        }
+    }
+}
 
-        node.neighbors.forEach((n) => {
-            copy.neighbors.push(dfs(n));
-        });
+const cloneNeighbors = (node, seen, queue) => {
+    for (const neighbor of node.neighbors) {
+        if (!seen.has(neighbor)) {
+            seen.set(neighbor, new Node(neighbor.val));/* Space O(N) */
+            queue.enqueue(neighbor);                   /* Space O(W) */
+        }
 
-        return copy;
-    };
+        const [ parentClone, neighborClone ] = [ seen.get(node), seen.get(neighbor) ];
 
-    return dfs(node);
-};
+        parentClone.neighbors.push(neighborClone);     /* Space O(V + E) */
+    }
+}