update

Author: tangweikun

CATEGORY.md

@@ -6,25 +6,6 @@ https://github.com/garciparedes
 
 https://garciparedes.me/#headers
 
-- Backtracking
-
-  - [ ] 22
-  - [ ] 39
-  - [ ] 40
-  - [ ] 46
-  - [ ] 47
-  - [ ] 60
-  - [ ] 77
-  - [ ] 78
-  - [ ] 90
-  - [ ] 131
-  - [ ] 211
-  - [ ] 216
-  - [ ] 306
-  - [ ] 357
-  - [ ] 872
-    - [ ] 17
-
 - Breadth First Search +5
 
   - [ ] 107
@@ -127,3 +108,11 @@ https://garciparedes.me/#headers
         - [ ] 55
           - [ ] 78
             - [ ] 90
+
+- Backtracking
+
+  - [ ] 17
+    - [ ] 22
+      - [ ] 78
+        - [ ] 306
+          - [ ] 872

src/131-palindrome-partitioning/20210730.js

@@ -0,0 +1,39 @@
+/**
+ * @param {string} s
+ * @return {string[][]}
+ */
+
+var partition = function (s) {
+  const res = [];
+  backtracking([], "", 0);
+  return res;
+
+  function backtracking(temp, preStr, index) {
+    if (index === s.length) {
+      if (preStr === "") {
+        res.push(temp);
+      }
+
+      return;
+    }
+    if (isPartition(preStr + s[index])) {
+      backtracking([...temp, preStr + s[index]], "", index + 1);
+    }
+
+    backtracking(temp, preStr + s[index], index + 1);
+  }
+
+  function isPartition(str) {
+    let left = 0;
+    let right = str.length - 1;
+    while (left < right) {
+      if (str[left] !== str[right]) return false;
+      left++;
+      right--;
+    }
+
+    return true;
+  }
+};
+
+console.log(partition("qbbc"));

src/216-combination-sum-iii/20210730.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} k
+ * @param {number} n
+ * @return {number[][]}
+ */
+var combinationSum3 = function (k, n) {
+  const res = [];
+  backtracking(0, [], 1);
+  return res;
+
+  function backtracking(sum, temp, index) {
+    if (temp.length > k || sum > n || index > 10) {
+      return;
+    }
+
+    if (temp.length === k) {
+      if (sum === n) {
+        res.push(temp);
+      }
+      return;
+    }
+
+    backtracking(sum + index, [...temp, index], index + 1);
+    backtracking(sum, temp, index + 1);
+  }
+};
+
+console.log(combinationSum3(9, 45));

src/216-combination-sum-iii/index.js

@@ -1,20 +1,19 @@
-// HELP:
-// backtracking
-
-export const combinationSum3 = (k, n) => {
-  let result = [];
-  backtracking(result, k, n, [], 0, 1);
-  return result;
-};
-
-const backtracking = function(result, k, n, temp, sum, start) {
-  if (sum === n && temp.length === k) {
-    result.push(temp);
-  } else {
-    for (let i = start; i < 10; i++) {
-      if (temp.indexOf(i) === -1) {
-        backtracking(result, k, n, temp.concat(i), sum + i, i + 1);
-      }
-    }
-  }
-};
+// backtracking
+
+export const combinationSum3 = (k, n) => {
+  let result = [];
+  backtracking(result, k, n, [], 0, 1);
+  return result;
+};
+
+const backtracking = function (result, k, n, temp, sum, start) {
+  if (sum === n && temp.length === k) {
+    result.push(temp);
+  } else {
+    for (let i = start; i < 10; i++) {
+      if (temp.indexOf(i) === -1) {
+        backtracking(result, k, n, temp.concat(i), sum + i, i + 1);
+      }
+    }
+  }
+};

src/306-additive-number/20210730.js

@@ -0,0 +1,30 @@
+/**
+ * @param {string} num
+ * @return {boolean}
+ */
+var isAdditiveNumber = function (num) {
+  let res = false;
+  backtracking([0], "", 0);
+  return res;
+
+  function backtracking(temp, pre, index) {
+    if (res) return;
+
+    if (index === num.length) {
+      if (pre === "" && Number(temp[temp.length - 2]) + Number(temp[temp.length - 3]) === Number(temp[temp.length - 1])) {
+        res = true;
+      }
+      return;
+    }
+
+    if (temp.length <= 2 || (temp.length > 2 && Number(temp[temp.length - 1]) + Number(temp[temp.length - 2]) === Number(pre + num[index]))) {
+      backtracking([...temp, pre + num[index]], "", index + 1);
+    }
+
+    if (!(pre + num[index]).startsWith("0")) {
+      backtracking(temp, pre + num[index], index + 1);
+    }
+  }
+};
+
+console.log(isAdditiveNumber("101"));

src/357-count-numbers-with-unique-digits/20210730.js

@@ -0,0 +1,10 @@
+export function countNumbersWithUniqueDigits(n) {
+  const dp = [1, 10];
+
+  for (let i = 2; i <= n; i++) {
+    const sum = Array.from({ length: i - 1 }, (_, index) => 9 - index).reduce((acc, num) => acc * num, 9);
+    dp[i] = dp[i - 1] + sum;
+  }
+
+  return dp[n];
+}

src/46-permutations/20210730.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function (nums) {
+  const res = [];
+  dfs([], nums);
+  return res;
+
+  function dfs(temp, arr) {
+    if (temp.length === nums.length) {
+      res.push(temp);
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+      dfs([...temp, arr[i]], [...arr.slice(0, i), ...arr.slice(i + 1)]);
+    }
+  }
+};
+
+console.log(permute([1, 2]));

src/47-permutations-ii/20210730.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permuteUnique = function (nums) {
+  nums.sort((x, y) => x - y);
+  const res = [];
+  dfs([], nums);
+  return res;
+
+  function dfs(temp, arr) {
+    if (temp.length === nums.length) {
+      res.push(temp);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] === arr[i - 1]) {
+        continue;
+      }
+      dfs([...temp, arr[i]], [...arr.slice(0, i), ...arr.slice(i + 1)]);
+    }
+  }
+};
+
+console.log(permuteUnique([1, 2, 2]));

src/60-permutation-sequence/20210730.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+var getPermutation = function (n, k) {
+  let count = 0;
+  let res = null;
+  dfs(
+    "",
+    Array.from({ length: n }, (_, index) => index + 1)
+  );
+  return res;
+
+  function dfs(temp, arr) {
+    if (count > k) return;
+
+    if (temp.length === n) {
+      count++;
+      if (count === k) {
+        res = temp;
+      }
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+      dfs(temp + arr[i], [...arr.slice(0, i), ...arr.slice(i + 1)]);
+    }
+  }
+};
+
+console.log(getPermutation(4, 9));

src/77-combinations/20210730.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number[][]}
+ */
+var combine = function (n, k) {
+  const res = [];
+  const arr = Array.from({ length: n }, (_, index) => index + 1);
+  backtracking([], arr);
+  return res;
+
+  function backtracking(temp, arr) {
+    if (temp.length === k) {
+      res.push(temp);
+      return;
+    }
+    for (let i = 0; i < arr.length; i++) {
+      backtracking([...temp, arr[i]], arr.slice(i + 1));
+    }
+  }
+};
+
+console.log(combine(4, 2));

src/90-subsets-ii/20210730.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var subsetsWithDup = function (nums) {
+  nums.sort((x, y) => x - y);
+  const res = [];
+  backtracking([], 0);
+  return res;
+
+  function backtracking(temp, index) {
+    if (index === nums.length) {
+      res.push(temp);
+      return;
+    }
+
+    backtracking([...temp, nums[index]], index + 1);
+
+    let i = index + 1;
+    while (i < nums.length && nums[i] === nums[i - 1]) {
+      i++;
+    }
+
+    backtracking(temp, i);
+  }
+};
+
+console.log(subsetsWithDup([1, 2, 2, 2]));