index the topics

Author: realdennis

src/subset-II.ts src/backtracking/subset-II.tssrc/subset-II.ts renamed to src/backtracking/subset-II.ts

@@ -7,7 +7,7 @@ function subsetsWithDup(nums: number[]): number[][] {
 
   const backtracking = (
     start = 0,
-    prevRes = [],
+    prevRes: number[] = [],
     visited = Array.from({ length: N }, () => false)
   ): void => {
     if (start === N) {

src/backtracking/sudoku-solver.ts

@@ -0,0 +1,51 @@
+/**
+ Do not return anything, modify board in-place instead.
+ */
+function solveSudoku(board: string[][]): void {
+  const isLegal = (row: number, col: number): boolean => {
+    const test = (strs: string[], target: string): boolean =>
+      strs.filter((val) => val === target).length === 1;
+    const target = board[row][col];
+
+    const rowItems = board[row];
+    if (!test(rowItems, target)) return false;
+
+    const colItems = board.map((_row) => _row[col]);
+    if (!test(colItems, target)) return false;
+
+    const boxRowStart = Math.floor(row / 3) * 3;
+    const boxColStart = Math.floor(col / 3) * 3;
+    const boxItems = board
+      .slice(boxRowStart, boxRowStart + 3)
+      .map((_row) => _row.slice(boxColStart, boxColStart + 3))
+      .reduce((prev, next) => [...prev, ...next], []);
+
+    if (!test(boxItems, target)) return false;
+
+    return true;
+  };
+
+  const getNextPos = (row: number, col: number): [number, number] =>
+    col + 1 === 9 ? [row + 1, 0] : [row, col + 1];
+
+  const candidates = "123456789";
+  let done = false;
+
+  const backtracking = (row: number, col: number): void => {
+    if (row === 9) done = true; // test done
+    if (done) return;
+    if (board[row][col] !== ".") return backtracking(...getNextPos(row, col)); // go to fill the next empty pos
+
+    for (const cand of candidates) {
+      // trial and error
+      board[row][col] = cand;
+      if (isLegal(row, col)) {
+        backtracking(...getNextPos(row, col));
+      }
+      if (done) return;
+      board[row][col] = ".";
+    }
+  };
+
+  backtracking(0, 0);
+}

src/backtracking/sum-off-all-subset-xor.ts

@@ -0,0 +1,23 @@
+function subsetXORSum(nums: number[]): number {
+  const N = nums.length;
+  const sets: number[][] = [];
+
+  const backtracking = (start = 0, prevRes: number[] = []): void => {
+    if (start === N) {
+      prevRes.length !== 0 && sets.push([...prevRes]);
+      return;
+    }
+    // includes nums[start] set
+    prevRes.push(nums[start]);
+    backtracking(start + 1, prevRes);
+    prevRes.pop();
+
+    // excludes nums[start] set
+    backtracking(start + 1, prevRes);
+  };
+  backtracking();
+
+  return sets
+    .map((set) => set.reduce((prev, next) => prev ^ next, 0))
+    .reduce((prev, next) => prev + next, 0);
+}

src/surrounded-regions.ts src/backtracking/surrounded-regions.tssrc/surrounded-regions.ts renamed to src/backtracking/surrounded-regions.ts

@@ -0,0 +1,60 @@
+export {};
+class TrieNode {
+  children: Map<string, TrieNode> = new Map();
+  word: string = "";
+}
+
+class Trie {
+  root: TrieNode = new TrieNode();
+  insert = (word: string): void => {
+    let node = this.root;
+    for (const ch of word) {
+      if (!node.children.has(ch)) node.children.set(ch, new TrieNode());
+      node = node.children.get(ch)!;
+    }
+    node.word = word; // store in the leaf node
+  };
+}
+
+function findWords(board: string[][], words: string[]): string[] {
+  /**
+
+Backtracking with Trie structure.
+
+Make a trie, and insert the word, we can put the word to the leaf node (so if we can travel here, we found it), and do backtracking, while we found it, we can de-dup the leaf node.
+
+**/
+  const ret: string[] = [];
+  const M = board.length;
+  const N = board[0].length;
+  const trie = new Trie();
+  for (const word of words) {
+    trie.insert(word);
+  }
+  const backtracking = (i: number, j: number, node: TrieNode): void => {
+    if (node.word !== "") {
+      ret.push(node.word);
+      node.word = ""; // de-dup
+    }
+    if (i < 0 || j < 0 || i >= M || j >= N) return; // boundary
+
+    const cur = board[i][j];
+    if (!node.children.has(cur)) return;
+
+    node = node.children.get(cur)!;
+    board[i][j] = "";
+    backtracking(i + 1, j, node);
+    backtracking(i, j + 1, node);
+    backtracking(i - 1, j, node);
+    backtracking(i, j - 1, node);
+    board[i][j] = cur;
+  };
+
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      backtracking(i, j, trie.root);
+    }
+  }
+
+  return ret;
+}

src/valid-sudoku.ts src/backtracking/valid-sudoku.tssrc/valid-sudoku.ts renamed to src/backtracking/valid-sudoku.ts

@@ -1,3 +1,4 @@
+export {};
 const findIndex = (
   A: number[],
   fn: (val: number, idx: number) => number

src/backtracking/word-search-2.ts

@@ -0,0 +1,36 @@
+export {};
+const findIndex = (
+  arr: number[],
+  fn: (val: number, index: number) => number
+): number => {
+  let lo = 0,
+    hi = arr.length;
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+
+    if (fn(arr[mid], mid) === 0) return mid;
+    if (fn(arr[mid], mid) < 0) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return lo - 1;
+};
+
+function search(nums: number[], target: number): boolean {
+  if (nums[nums.length - 1] === target) return true;
+  while (nums[0] === nums[nums.length - 1]) {
+    nums.pop();
+  }
+  // [4,4,4,5]
+  const maxIdx = findIndex(nums, (val: number, index: number): number => {
+    if (val < nums[0]) {
+      return 1;
+    } else {
+      return -1;
+    }
+  });
+
+  nums = [...nums.slice(maxIdx + 1), ...nums.slice(0, maxIdx + 1)];
+
+  const targetIdx = findIndex(nums, (val) => val - target);
+  return nums[targetIdx] === target;
+}