Catalogue of series articles
I Array type problem solving method 1: dichotomy
II Array type problem solving method 2: Double finger needle method
III Array type problem solving method 3: sliding window
IV Array type problem solving method 4: simulation
V The basic operation and classic topics of the linked list
Vi Classic title of hash table
VII Classic title of string
VIII KMP of string
IX Solution: double pointer
X Classic title of stack and queue
Xi top-K problem in stack and queue
XII The first, middle and last order traversal of binary tree
XIII Sequence traversal of binary tree and related topics
XIV Binary tree part of binary tree attributes related topics
XV Modification and construction of binary tree in binary tree chapter
XVI Properties of binary search tree
XVII The problem of common ancestor in binary tree discourse
XVIII Modification and construction of binary search tree in binary tree chapter
Updating
preface
The question brushing route comes from: Code Capriccio
Combinatorial problem: find the set of k numbers according to certain rules in N numbers
Backtracking algorithm is a pure violent search method, which is a kind of DFS (depth first search) in tree structure. It is used to solve some problem types that can not be written by normal violent solutions due to the change of the number of layers of the cycle. It is also an exhaustive list of all results, but pruning can be carried out in the process.
In backtracking algorithms, global variables are usually used to record paths and states. For the path and state recorded in the process of downward recursion, after a path recursion is completed and the lower recursion returns to the upper recursion, it is necessary to backtrack (return the state to before entering the lower recursion).
Inscription
77. Portfolio
Leetcode link
Given two integers n and k, returns the combination of all possible k numbers in the range [1, n]. You can return answers in any order.
Solution:
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> combine(int n, int k) {
backtracking(n, k, 1);
return res;
}
public void backtracking(int n, int k, int start) {
// End condition: path size() == k
if (path.size() == k) {
// Add to result set and return
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i <= n; i++) {
path.add(i);
// Because integers cannot be repeated, the lower level recursion needs to start from the starting position i of this level recursion plus one position
backtracking(n, k, i + 1);
// Backtracking to remove the value added before this recursion
path.remove(path.size() - 1);
}
}
}
Pruning Optimization:
Number of stored elements: path size()
You also need to find the number of elements: K - path size()
The starting position can be traversed at most from: n - (k - path.size()) + 1
...
for (int i = start; i <= n - (k - path.size()) + 1; i++) {
...
}
216. Combined sum III
Leetcode link
Find the combination of all k numbers whose sum is n. Only positive integers of 1 - 9 are allowed in the combination, and there are no duplicate numbers in each combination.
Solution:
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
int sum = 0;
public List<List<Integer>> combinationSum3(int k, int n) {
backtracking(k, n, 1);
return res;
}
public void backtracking(int k, int n, int start) {
// End condition
if (path.size() > k || sum > n) {
// And is greater than n or the number of elements collected is greater than k
return;
}
if (path.size() == k && sum == n) {
// The number of k has been collected, and the sum is equal to n
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i <= 9 - (k - path.size()) + 1; i++) {
path.add(i);
sum += i;
// The number is not repeated, and the next round of recursion starts from i + 1
backtracking(k, n, i + 1);
// Both sum and path should be traced back
path.remove(path.size() - 1);
sum -= i;
}
}
}
Save sum without using global variables, hide backtracking as recursive parameters, and make the code more concise
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> combinationSum3(int k, int n) {
int sum = 0;
backtracking(k, n, 1, sum);
return res;
}
public void backtracking(int k, int n, int start, int sum) {
if (path.size() > k || sum > n) {
return;
}
if (path.size() == k && sum == n) {
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i <= 9 - (k - path.size()) + 1; i++) {
path.add(i);
//sum += i;
// Pass sum + i as a parameter into the lower level recursion
backtracking(k, n, i + 1, sum + i);
path.remove(path.size() - 1);
// When sum + i is taken as the parameter, the sum of this layer does not change, and there is no need to backtrack after returning to this layer
//sum -= i;
}
}
}
39. Combination sum
Leetcode link
Solution:
For the sake of code simplicity, sum is still placed in recursive parameters
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
backtracking(candidates, target, 0, 0);
return res;
}
public void backtracking(int[] nums, int target, int start, int sum) {
if (sum > target) {
return;
}
if (sum == target) {
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i < nums.length; i++) {
path.add(nums[i]);
// A number can be used multiple times, and the subscript i is added by one
backtracking(nums, target, i, sum + nums[i]);
path.remove(path.size() - 1);
}
}
}
40. Combined sum II
Leetcode link
Given a candidate number set candidates and a target number target, find out all combinations in candidates that can make the sum of numbers target. Each number in candidates can only be used once in each combination.
Note: the solution set cannot contain duplicate combinations.
Solution:
Sort first, you can put the same numbers together
Because there are duplicate numbers in the array, duplicate combinations are not allowed in the second return list, such as:
Array: num [1, 1, 2, 3] target = 4
[1, 3] and [1, 3]. Since the second 1 is repeated with the previous 1, the second [1, 3] obviously needs pruning, but the half segment condition cannot only have nums [I - 1] = nums [i]. Look at [1, 1, 2]. When the first 1 enters the second layer of recursion, the second 1 here is useful, because the 1 here is the starting position of this layer of recursion
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
// sort
Arrays.sort(candidates);
backtracking(candidates, target, 0, 0);
return res;
}
public void backtracking(int[] nums, int target, int start, int sum) {
// The end condition here is placed in the for loop judgment condition of the upper layer, which simplifies the code and reduces the number of recursion
// if (sum > target) {
// return;
// }
// End condition
if (sum == target) {
// Add and return
res.add(new ArrayList<>(path));
return;
}
for (int i = start; i < nums.length && sum + nums[i] <= target; i++) {
if (i > start && nums[i] == nums[i - 1]) {
// It is not the starting position. If it is repeated with the previous number, skip directly
continue;
}
path.add(nums[i]);
backtracking(nums, target, i + 1, sum + nums[i]);
// to flash back
path.remove(path.size() - 1);
}
}
}
17. Letter combination of telephone number
Leetcode link
Given a string containing only numbers 2-9, returns all the letter combinations it can represent. The answers can be returned in any order. The mapping of numbers to letters is given as follows (the same as telephone keys). Note that 1 does not correspond to any letter.
Solution:
- The array holds the mapping relationship between numbers and strings
- The recursive string of each layer is related to the depth of recursion, and the depth of recursion is determined by the subscript of digits, so the parameter list needs a deep to record
- Before each traversal, you need to get the string to be traversed by the recursion of this layer, that is, the mapping string of the number corresponding to the depth of recursion
class Solution {
List<String> res = new ArrayList<>();
// sb here can also be used as a recursive parameter to hide backtracking
StringBuilder sb = new StringBuilder();
public List<String> letterCombinations(String digits) {
if (digits.equals("") || digits == null) {
return res;
}
// Array save mapping relationship
String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
backtracking(digits, numString, 0);
return res;
}
public void backtracking(String digits, String[] numString, int deep) {
// End condition
if (deep == digits.length()) {
// Add to result set and return
res.add(sb.toString());
return;
}
// The mapping array starts with the 0 subscript, digits Charat (deep) gets the character form of numbers,
// digits.charAt(deep) - '0' gets the corresponding subscript
String s = numString[digits.charAt(deep) - '0'];
for (int i = 0; i < s.length(); i++) {
sb.append(s.charAt(i));
backtracking(digits, numString, deep + 1);
// to flash back
sb.deleteCharAt(sb.length() - 1);
}
}
}
summary
Backtracking template:
public void backtracking(parameter) {
if (Termination conditions) {
// Store results and return
Add to return list;
return;
}
if (Other termination conditions) {
// Return directly, or put it into the for loop for judgment
return;
}
for (Selection: Elements in the collection of this layer (the number of node children in the tree is the size of the collection)) {
Processing node;
backtracking(Path, selection list);
Backtracking, undo processing results;
}
}
- The returned list is generally used as a global variable, because it is concise and reduces the recursive parameter list
- Similar to sum and string, which need to be dynamically maintained and backtracked in the recursive process, in addition to being used as global variables, they can also be used as recursive parameters to hide backtracking.
- Pruning usually modifies the end condition of the for loop, similar to the above questions