回溯算法基础题练习

「这是我参与2022首次更文挑战的第9天，活动详情查看：2022首次更文挑战」。

回溯法，一般用来解决：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等等

一般来说，回溯法可以套用下面这个模板来解决：

void backtracking(参数) { 
  if (终止条件) {
    存放结果; 
    return; 
  } 
  
  for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
     处理节点; 
     backtracking(路径，选择列表); 
     // 递归 回溯，撤销处理结果 
  }
}

77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

  示例 1：

输入： n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入： n = 1, k = 1
输出： [[1]]

就是从 1, 2, 3, ...n 选取 n 个数。

以 1, 2, 3, 4 k = 2 为例

const combine = function (n, k) {
  // 返回的结果集
  let result = []
  // 单层遍历的结果
  let list = []

  const backtracking = (n, k, startIndex) => {
    // 当 path.length === k, 终止
    if (list.length === k) {
      result.push([...list])
      return
    }

    // 单层搜索
    for (let i = startIndex; i <= n; ++i) {
      // 处理节点
      list.push(i)
      // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
      backtracking(n, k, i + 1)
      list.pop()
    }
  }

  // 题目中说，从 1 开始遍历到 n
  backtracking(n, k, 1)
  return result
};

216. 组合总和 III

找出所有相加之和为 n 的 k 个数的组合。 组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

• 所有数字都是正整数。
• 解集不能包含重复的组合。 

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

这道题和 77. 组合 思路基本上是一样的。只多了一个条件，相加等于 n。因此，只需要修改两处代码即可。

var combinationSum3 = function (k, n) {
  let result = []
  let path = []

  let backtracking = (n, k, startIndex) => {
    if (path.length === k && path.reduce((a, b) => a + b) === n) {
      result.push([...path])
      return
    }

    for (let i = startIndex; i <= 9; i++) {
      path.push(i)
      backtracking(n, k, i + 1)
      path.pop()
    }
  }

  backtracking(n, k, 1)
  return result
};

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

 

示例 1：

输入： digits = "23"
输出： ["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入： digits = ""
输出： []

示例 3：

输入： digits = "2"
输出： ["a","b","c"]

数字和字母可以使用map或者数组进行映射。

var letterCombinations = function (digits) {
  const digitsLength = digits.length;
  const map = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"];
  if (!digitsLength) return [];
  if (digitsLength === 1) return map[digits].split("");

  let result = [];
  let path = [];

  const backtracking = (startIndex) => {
    if (path.length === digitsLength) {
      result.push(path.join(""));
      return;
    }

    for (const v of map[digits[startIndex]]) {
      path.push(v);
      backtracking(startIndex + 1);
      path.pop();
    }
  }

  backtracking(0);
  return result;
};

39. 组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入： candidates = [2,3,6,7], target = 7
输出： [[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

示例 4：

输入: candidates = [1], target = 1
输出: [[1]]

示例 5：

输入: candidates = [1], target = 2
输出: [[1,1]]

backtracking(sum, i), 不用 i+1，表示可以重复读取当前的数。

var combinationSum = function (candidates, target) {
  let result = [];
  let path = [];
  let startIndex = 0;
  let sum = 0

  let backtracking = (sum, startIndex) => {
    if (sum > target) {
      return;
    }
    if (sum === target) {
      result.push([...path])
      return
    }

    for (let i = startIndex; i < candidates.length; i++) {
      sum += candidates[i];
      path.push(candidates[i]);
      backtracking(sum, i);
      sum -= candidates[i];
      path.pop();
    }
  }

  backtracking(sum, startIndex)
  return result;
};

40. 组合总和 II

给你一个由候选元素组成的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个元素在每个组合中只能使用 一次 。

注意： 解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

candidates.sort() + candidates[i] === candidates[i - 1] && used[i - 1] == false ===> 这是为了去重，保证每个元素在每个组合中只能使用一次。

var combinationSum2 = function (candidates, target) {
  let result = [];
  let path = [];
  let startIndex = 0;
  let sum = 0;
  let used = new Array(candidates.length).fill(false);

  candidates.sort();

  let backtracking = (sum, startIndex) => {
    if (sum > target) {
      return;
    }
    if (sum === target) {
      result.push([...path])
      return
    }

    for (let i = startIndex; i < candidates.length; i++) {
      if (candidates[i] === candidates[i - 1] && used[i - 1] == false) continue;
      sum += candidates[i];
      path.push(candidates[i]);
      used[i] = true;
      backtracking(sum, i + 1, used);
      used[i] = false;
      sum -= candidates[i];
      path.pop();
    }
  }

  backtracking(sum, startIndex)
  return result;
};

131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入： s = "aab"
输出： [["a","a","b"],["aa","b"]]

示例 2：

输入： s = "a"
输出： [["a"]]

每次分割字符串之后，判断该字符串是否符合回文字符串。

var partition = function (s) {
  let result = [];
  let path = [];

  let backtracking = (startIndex) => {
    if (startIndex === s.length) {
      result.push([...path])
    }

    for (let i = startIndex; i < s.length; i++) {
      if (isPalindrome(s, startIndex, i)) {
        let str = s.substr(startIndex, i - startIndex + 1);
        path.push(str);
      } else {
        continue
      }
      backtracking(i + 1)
      path.pop();
    }
  }

  backtracking(0);
  return result;
};

let isPalindrome = function (s, i, j) {
  while (i <= j) {
    if (s[i] !== s[j]) {
      return false;
    }
    i++;
    j--;
  }
  return true;
}

93. 复原 IP 地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

• 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你不能重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入： s = "25525511135"
输出： ["255.255.11.135","255.255.111.35"]

示例 2：

输入： s = "0000"
输出： ["0.0.0.0"]

示例 3：

输入： s = "1111"
输出： ["1.1.1.1"]

示例 4：

输入： s = "010010"
输出： ["0.10.0.10","0.100.1.0"]

示例 5：

输入： s = "101023"
输出： ["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

套用模板，处理异常情况

var restoreIpAddresses = function (s) {
  let result = [];
  let path = [];

  const backtracking = (startIndex) => {
    const len = path.length;
    if (len > 4) return;
    if (len === 4 && startIndex === s.length) {
      result.push(path.join('.'))
      return;
    }

    for (let j = startIndex; j < s.length; j++) {
      const str = s.substr(startIndex, j - startIndex + 1);
      if (str.length > 3 || +str > 255) break;
      if (str.length > 1 && str[0] === '0') break;
      path.push(str);
      backtracking(j + 1);
      path.pop();
    }
  }

  backtracking(0)
  return result
}

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入： nums = [1,2,3]
输出： [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入： nums = [0]
输出： [[],[0]]

var subsets = function (nums) {
  let result = []
  let list = []
  const backtracking = (startIndex, list) => {
    // 递归结束条件
    if (startIndex === nums.length) {
      // 加入解集,结束当前的递归
      result.push([...list])
      return;
    }
    // 选择这个元素
    list.push(nums[startIndex])
    // 往下递归
    backtracking(startIndex + 1, list)
    // 递归结束，撤销选择
    list.pop()
    // 不选这个元素，往下递归
    backtracking(startIndex + 1, list)
  }
  backtracking(0, list)
  return result
};