Java算法之解题套路

Java算法之动态规划解题套路

开始学习动态规划之前，我们必须明白动态规划是用来解决什么问题的？

动态规划问题的一般形式就是求最值，解决动态规划的核心问题在于穷举，需要你熟练掌握递归思维，列出正确的【状态转移方程】，而且你还需要判断问题是否具备【最优子结构】。动态规划还可能会存在【重叠子问题】

动态规划解题的一般思维：

明确【状态】------>明确【选择】------>定义dp数组|函数的含义

解法框架

python 复制代码

#自顶向下递归的动态规划
def dp(状态1，状态2):
    for 选择 in 所有可能的选择：
    	#此时的状态因为做了选择而改变
        result = 求最值(result,dp(状态1，状态2，......))
    return result

# 自底向上迭代的动态规划
# 初始化base case
dp[0][0][...] = base case
# 进行状态转移
for 状态1 in 状态1的所有取值:
    for 状态2 in 状态2的所有取值:
        for ...
        	dp[状态1][状态2][...] = 求最值(选择1，选择2...)

509. 斐波那契数

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
复制代码
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

示例 1：
复制代码
输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1
示例 2：
复制代码
输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2
示例 3：
复制代码
输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3
提示：

0 <= n <= 30

java 复制代码

class Solution {
    public int fib(int n) {
        //备忘录全初始化为0
        int[] memo = new int[n + 1];
        //进行带备忘录的递归
        return dp(memo,n);
    }
    private int dp(int[] memo,int n){
        //base case
        if(n == 0 || n == 1) return n;
        //已经计算过，不用再计算了
        if(memo[n] != 0) return memo[n];
        memo[n] = dp(memo,n-1) + dp(memo,n-2);
        return memo[n];
    }
}

可以看到上面的代码中我们用了一个备忘录的东西，本质上就是把一颗存在巨量冗余的递归书剪枝成不存在冗余的递归图。
在这个基础上我们对代码进行进一步的优化（把备忘录独立出来做成一张表）

java 复制代码

class Solution {
    public int fib(int n) {
        if(n == 0) return 0;
        int[] dp = new int[n + 1];
        //base case
        dp[0] = 0;dp[1] = 1;
        //状态转移
        for(int i = 2; i <= n; i ++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：
复制代码
输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1
示例 2：
复制代码
输入：coins = [2], amount = 3
输出：-1
示例 3：
复制代码
输入：coins = [1], amount = 0
输出：0
提示：

1 <= coins.length <= 12

1 <= coins[i] <= 231 - 1

0 <= amount <= 104

java 复制代码

class Solution {
    public int coinChange(int[] coins, int amount) {
        return dp(coins,amount);
    }
    //定义：要凑出金额n，至少要dp（coins，n）个硬币
    private int dp(int[] coins,int amount){
        //base case
        if(amount == 0) return 0;
        if(amount < 0) return -1;
        int res = Integer.MAX_VALUE;
        for(int coin : coins){
            //计算子问题的结果
            int sumProblem = dp(coins,amount - coin);
            //子问题无解则跳过
            if(sumProblem == -1) continue;
            //在子问题中选择最优解，然后加1
            res = Math.min(res,sumProblem + 1);
        }
        return res == Integer.MAX_VALUE ? -1 : res;
    }
}

以上算法为此题的暴力解法，接下来我们考虑使用备忘录来优化

java 复制代码

class Solution {
    int[] memo;
    public int coinChange(int[] coins, int amount) {
        memo = new int[amount + 1];
        //备忘录初始化为一个不会被取到的特殊值，代表还没有被计算
        Arrays.fill(memo,-10000);
        return dp(coins,amount);
    }
    private int dp(int[] coins, int amount){
        if(amount == 0) return 0;
        if(amount < 0) return -1;
        //查备忘录，防止重复计算
        if(memo[amount] != -10000){
            return memo[amount];
        }
        int res = Integer.MAX_VALUE;
        for(int coin : coins){
            //计算子问题的结果
            int subProblem = dp(coins,amount - coin);
            //子问题无解跳过
            if(subProblem == -1) continue;
            //在子问题中选择最优解，然后加1
            res = Math.min(res,subProblem + 1);
        }
        //将最优解存入备忘录
        memo[amount] = (res == Integer.MAX_VALUE ? -1 : res);
        return memo[amount];
    } 
}

java 复制代码

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount+1];
        //数组大小为amount+1，初始值也为amount+1
        Arrays.fill(dp,amount+1);
        //base case
        dp[0] = 0;
        //外层for循环遍历所有状态的所有取值
        for(int i = 0; i < dp.length; i ++){
            //内层for循环求所有选择的最小值
            for(int coin : coins){
                //子问题无解，跳过
                if(i - coin < 0){
                    continue;
                }
                dp[i] = Math.min(dp[i],1 + dp[i - coin]);
            }
        }
        return (dp[amount] == amount + 1) ? -1:dp[amount];
    }
}

Java算法之回溯算法解题框架

抽象的说，回溯问题实际上就是在遍历一颗决策树，树的每个叶子结点都是一个合法答案，把这些答案搜集起来就是所有的答案。

回溯算法三要素：路径、选择列表、结束条件

python 复制代码

result = []
def backtrack(路径，选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrack(路径，选择列表)
        撤销选择

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：
复制代码
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：
复制代码
输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：
复制代码
输入：nums = [1]
输出：[[1]]
提示：

1 <= nums.length <= 6

-10 <= nums[i] <= 10

nums 中的所有整数 互不相同

java 复制代码

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    //主函数，输入一组不重复的数字，返回他们的全排列
    public List<List<Integer>> permute(int[] nums) {
        //记录【路径】
        LinkedList<Integer> track = new LinkedList<>();
        //【路径】中的元素会被标记为true，避免重复使用
        boolean[] used = new boolean[nums.length];
        backtrack(nums,track,used);
        return res;
    }
    //【路径】：记录在track中
    //选择列表：nums中不存在于track中的元素（used[i] = false）
    //结束条件：nums中的元素全部在track中出现
    private void backtrack(int[] nums,LinkedList<Integer> track,boolean[] used){
        //触发结束条件
        if(track.size() == nums.length){
            res.add(new LinkedList(track));
            return;
        }
        for(int i = 0; i < nums.length; i ++){
            //排除不合法的选择
            if(used[i]){
                //nums[i]已经在track中
                continue;
            }
            //做选择
            track.add(nums[i]);
            used[i] = true;
            //进入下一层决策树
            backtrack(nums,track,used);
            //取消选择
            track.removeLast();
            used[i] = false;
        }
    }
}

**回溯算法不像动态规划一样存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。**在编写backtrack函数式，需要维护走过【路径】和当前可以做的【选择列表】，当触发结束条件式，将【路径】计入结果集。

java算法之BFS框架求解

对于BFS问题，最典型的应用就是迷宫游戏了，还有比如说给两个单词，要求你通过某些变换，把其中一个编程另一个，每次可以替换、删除、插入一个字符，最少要操作几次。

java 复制代码

//从s开始BFS遍历图的所有节点，且记录遍历的步数
//当走到目标节点target时，返回步数
int bfs(int s, int target){
    boolean[] visited = new boolean[graph.size()];
    Queue<Integer> q = new LinkedList<>();
    q.offer(s);
    visited[s] = true;
    //记录从s走到target的步数
    int step = 0;
    while(!q.isEmpty()){
        int sz = q.size();
        for(int i = 0; i < sz; i ++){
            int cur = q.poll();
            System.out.println("visit " + cur + " at step " + step);
            //判断是否到达终点
			if(cur == target){
                return step;
            }
            //将邻居节点加入队列中
            for(int to : neighborsOf(cur)){
                if(!visited[to]){
                    q.offer(to);
                    visited[to] = true;
                }
            }
        }
        step ++;
    }
    //如果走到这里，还是没有走到target，说明没有目标节点
    return -1;
}

773. 滑动谜题

在一个 2 x 3 的板上（board）有 5 块砖瓦，用数字 1~5 来表示, 以及一块空缺用 0 来表示。一次移动定义为选择 0 与一个相邻的数字（上下左右）进行交换.

最终当板 board 的结果是 [[1,2,3],[4,5,0]] 谜板被解开。

给出一个谜板的初始状态 board ，返回最少可以通过多少次移动解开谜板，如果不能解开谜板，则返回 -1 。

示例 1：
复制代码
输入：board = [[1,2,3],[4,0,5]]
输出：1
解释：交换 0 和 5 ，1 步完成
示例 2:
复制代码
输入：board = [[1,2,3],[5,4,0]]
输出：-1
解释：没有办法完成谜板
示例 3:
复制代码
输入：board = [[4,1,2],[5,0,3]]
输出：5
解释：
最少完成谜板的最少移动次数是 5 ，
一种移动路径:
尚未移动: [[4,1,2],[5,0,3]]
移动 1 次: [[4,1,2],[0,5,3]]
移动 2 次: [[0,1,2],[4,5,3]]
移动 3 次: [[1,0,2],[4,5,3]]
移动 4 次: [[1,2,0],[4,5,3]]
移动 5 次: [[1,2,3],[4,5,0]]
提示：

board.length == 2

board[i].length == 3

0 <= board[i][j] <= 5

board[i][j] 中每个值都不同

java 复制代码

class Solution {
    public int slidingPuzzle(int[][] board) {
        String target = "123450";
        //将2*3数组专户为字符串作为bfs的起点
        String start = "";
        for(int i = 0 ; i < board.length;i ++){
            for(int j = 0; j < board[i].length; j ++){
                start = start + board[i][j];
            }
        }
        //BFS
        Queue<String> q = new LinkedList<>();
        HashSet<String> visited = new HashSet<>();
        //从起点开始bfs
        q.offer(start);
        visited.add(start);
        int step = 0;
        while(!q.isEmpty()){
            int sz = q.size();
            for(int i = 0; i < sz; i ++){
                String cur = q.poll();
                if(cur.equals(target)){
                    return step;
                }
                //将数字0和相邻位置的数字交换
                for(String neighborBoard : getNeighbors(cur)){
                    if(!visited.contains(neighborBoard)){
                        q.offer(neighborBoard);
                        visited.add(neighborBoard);
                    }
                }
            }
            step ++;
        }
        //bfs结束
        return -1;
    }
    private List<String> getNeighbors(String board){
        //记录一维字符串的相邻索引
        int[][] mapping = new int[][] {
            {1,3},
            {0,4,2},
            {1,5},
            {0,4},
            {3,1,5},
            {4,2}
        };
        int idx = board.indexOf('0');
        List<String> neighbors = new ArrayList<>();
        for(int adj : mapping[idx]){
            String new_board = swap(board.toCharArray(),adj,idx);
            neighbors.add(new_board);
        }
        return neighbors;
    }
    private String swap(char[] chars,int i,int j){
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
        return new String(chars);
    }
}

752. 打开转盘锁

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。

锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。

列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

示例 1:
复制代码
输入：deadends = ["0201","0101","0102","1212","2002"], target = "0202"
输出：6
解释：
可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。
注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的，
因为当拨动到 "0102" 时这个锁就会被锁定。
示例 2:
复制代码
输入: deadends = ["8888"], target = "0009"
输出：1
解释：把最后一位反向旋转一次即可 "0000" -> "0009"。
示例 3:
复制代码
输入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
输出：-1
解释：无法旋转到目标数字且不被锁定。
提示：

1 <= deadends.length <= 500

deadends[i].length == 4

target.length == 4

target 不在 deadends 之中

target 和 deadends[i] 仅由若干位数字组成

java 复制代码

class Solution {
    public int openLock(String[] deadends, String target) {
        //记录需要跳过的密码
        Set<String> deads = new HashSet<>();
        for(String s : deadends) deads.add(s);
        if(deads.contains("0000")) return -1;
        //记录已经穷举过的密码，防止走回头路
        Set<String> visited = new HashSet<>();
        Queue<String> q = new LinkedList<>();
        //从起点开始搜索
        int step = 0;
        q.offer("0000");
        visited.add("0000");
        while(!q.isEmpty()){
            int sz = q.size();
            for(int i = 0; i < sz; i ++){
                String cur = q.poll();
                if(cur.equals(target)){
                    return step;
                }
                //讲一个节点的合法相邻节点加入队列
                for(String neighbor : getNeighbors(cur)){
                    if(!visited.contains(neighbor) && !deads.contains(neighbor)){
                        q.offer(neighbor);
                        visited.add(neighbor);
                    }
                }
            }
            step ++;
        }
        //bfs结束
        return -1;
    }
    //将s[i]向上波动一次
    String plusOne(String s,int i){
        char[] ch = s.toCharArray();
        if(ch[i] == '9'){
            ch[i] = '0';
        }else{
            ch[i] += 1;
        }
        return new String(ch);
    }
    //将s[i]向下波动一次
    String minusOne(String s,int i){
        char[] ch = s.toCharArray();
        if(ch[i] == '0'){
            ch[i] = '9';
        }else{
            ch[i] -= 1;
        }
        return new String(ch);
    }
    //将s的每一位向上波动一次或者向下波动一次，总共有8中相邻密码
    List<String> getNeighbors(String s){
        List<String> neighbors = new ArrayList<>();
        for(int i = 0; i < 4; i ++){
            neighbors.add(plusOne(s,i));
            neighbors.add(minusOne(s,i));
        }
        return neighbors;
    }
}

Java算法之二叉树系列算法

解决二叉树问题时需要有以下思维：

是否可以通过一次遍历二叉树得到答案
是否可以定义一个递归函数，通过子问题的答案推导出问题的答案

我们还是那个老生常谈的问题，快速排序和归并排序我们分别可以看成前序遍历和后序遍历

java 复制代码

//快速排序的代码框架
void sort(int[] nums,int left,int right){
    //前序遍历位置
    //通过交换元素构建分界点p
    int p = partition(nums,left,right);
    //
    sort(nums,left,p-1);
    sort(nums,p + 1,right);
}
//归并排序代码框架
void sort(int[] nums,int left,int right){
    int mid = (left + right)/2;
    //排序[left,mid]
    sort(nums,left,mid);
    //排序(mid,right]
    sort(nums,mid+1,right);
    //后序位置
    //合并[left,mid]和(mid,right]
    merge(nums,mid,left,right);
}

java 复制代码

//二叉树的DFS
void traverse(ListNode root){
    if(root == null){
        return;
    }
    //前序位置
    traverse(root.left);
    //中序位置
    teaverse(root.right);
    //后序位置
}

二叉树题目的递归解法可以分两类思路，第一类是遍历一遍二叉树得到答案，第二类是通过分解问题计算出答案，这两类分别对应回溯和动态规划

104. 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：
复制代码
输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：
复制代码
输入：root = [1,null,2]
输出：2
提示：

树中节点的数量在 [0, 104] 区间内。

-100 <= Node.val <= 100

java 复制代码

//回溯思路
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //记录最大深度
    int res = 0;
    //记录遍历到节点的深度
    int depth = 0;
        
    public int maxDepth(TreeNode root) {
       traverse(root);
       return res;
    }
    private void traverse(TreeNode root){
        if(root == null){
            return;
        }
        //前序位置
        depth++;
        if(root.left == null && root.right == null){
            //到达叶子节点，更新深度
            res = Math.max(res,depth);
        }
        traverse(root.left);
        traverse(root.right);
        //后序位置
        depth--;
    }
}

java 复制代码

//动态规划思路
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        //利用定义，计算左右子树的最大深度
        int leftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        //整棵树的最大深度就等于左右子树的最大深度加上根节点的1
        int res = Math.max(leftMax,rightMax) + 1;
        return res;
    }
}

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

示例 1：

**输入：**root = [1,null,2,3]

输出：[1,2,3]

解释：

示例 2：

**输入：**root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[1,2,4,5,6,7,3,8,9]

解释：

示例 3：

**输入：**root = []

输出：[]

示例 4：

**输入：**root = [1]

输出：[1]

提示：

树中节点数目在范围 [0, 100] 内

-100 <= Node.val <= 100

java 复制代码

//回溯思路
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //存放前序遍历的结果
    List<Integer> res = new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        traverse(root);
        return res;
    }
    private void traverse(TreeNode root){
        if(root == null){
            return;
        }
        //前序位置
        res.add(root.val);
        traverse(root.left);
        traverse(root.right);
    }
}

java 复制代码

//动态规划思路（将左子树的前序遍历和右子树的前序遍历加到根节点）
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        //前序遍历结果，root.val在第一个
        res.add(root.val);
        //将左子树的前序遍历加到根节点后
        res.addAll(preorderTraversal(root.left));
        //将右子树的前序遍历加上
        res.addAll(preorderTraversal(root.right));
        return res;
    }
}

那么对于我们来说后序遍历有什么特点呢，其实从遍历模板看也能看出，后序遍历的效率会更高，因为后序遍历我们可以拿到更多的信息（前序遍历只能拿到根节点的信息，中序遍历可以拿到根节点+左节点，后序遍历全可以拿到）

一旦发现题目和子树有关，那大概率要给函数设定合理的定义和返回值，在后序位置编写代码
543. 二叉树的直径

给你一棵二叉树的根节点，返回该树的直径。

二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的长度由它们之间边数表示。

示例 1：
复制代码
输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2：
复制代码
输入：root = [1,2]
输出：1
提示：

树中节点数目在范围 [1, 104] 内

-100 <= Node.val <= 100

java 复制代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //记录最大直径的长度
    int res = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return res;
    }
    private int maxDepth(TreeNode root){
        if(root == null) {
            return 0;
        }
        int leftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        //后序位置顺便计算一下最大直径
        res = Math.max(res,leftMax + rightMax);
        return 1 + Math.max(leftMax,rightMax);
    }
}

从树的视角来看动态规划/回溯/DFS算法的区别

动态规划算法属于分解问题(分治)的思路，他的关注点在整颗子树
回溯算法属于遍历的思路，他的关注点在于节点间的树枝
DFS算法属于遍历的思路，他的关注点在于节点

层序遍历

java 复制代码

//简单的不能再简单了，直接上框架了
void levelTraverse(TreeNode root){
    if(root == null) return;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
    //从上到下遍历二叉树的每一层
    while(!q.isEmpty()){
        int sz = q.size();
        for(int i = 0; i < sz; i ++){
            TreeNode cur = q.poll();
            //将下一节点放入队列
            if(root.left!=null){
                q.offer(cur.left);
            }
            if(cur.right!=null){
                q.offer(cur.right);
            }
        }
    }
}

回溯算法秒杀排列/组合/子集问题

元素无重不可复选，即nums中的元素都是唯一的，每个元素最多只能被使用一次

java 复制代码

//组合/子集问题回溯算法框架
void backtrack(int[] nums,int start){
    //回溯算法标准框架
    for(int i = start; i < nums.length; i ++){
        //做选择
        track.add(nums[i]);
        //注意参数,进入下一层回溯
        backtrack(nums,i + 1);
        //撤销选择
        track.removeLast();
    }
}
//排列问题回溯算法框架
void backtrack(int[] nums){
   	for(int i = 0; i < nums.length; i ++){
        //剪枝逻辑
        if(used[i]){
            continue;
        }
        //做选择
        used[i] = true;
        track.add(nums[i]);
        //进入下一层回溯
        backtrack(nums);
        //撤销选择
        track.removeLast();
        used[i] = false;
    }
}

元素可重不可复选，即nums中的元素可以存在重复，每个元素最多只能被使用一次

java 复制代码

Arrays.sort(nums);
//组合/子集问题回溯算法框架
void backtrack(int[] nums,int start){
    //回溯算法标准模板
    for(int i = start; i < nums.length; i ++){
        //剪枝逻辑，跳过相同值的相邻树枝
        if(nums[i] == nums[i - 1] && i > start){
            continue;
        }
        //做选择
        track.add(nums[i]);
        //进入下一层回溯
        backtrack(nums,i +1);
        //撤销选择
        track.removeLast();
    }
}
//排列问题回溯算法框架
Arrays.sort(nums);
void backtrack(int[] nums){
    for(int i = 0; i < nums.length; i ++){
        //剪枝逻辑
        if(used[i]){
            continue;
        }
        //剪枝逻辑，固定相同元素在排列中的相对位置
        if(i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
            continue;
        }
        //做选择
        track.add(nums[i]);
        used[i] = true;
        //进入下一层回溯
        backrtack(nums);
        //撤销选择
        used[i] = fasle;
        track.removeLast();
    }
}

元素无重可重复选

java 复制代码

//组合/子集问题回溯算法框架
void backtrack(int[] nums,int start){
    for(int i = start; i < nums.length; i ++){
        //做选择
        track.add(nums[i]);
        //进入下一层回溯
        backtrack(nums,i);
        //撤销选择
        track.removeLast();
    }
}
//排列问题回溯算法框架
void backtrack(int[] nums){
    for(int i = 0; i < nums.length; i ++){
        //做选择
        track.add(nums[i]);
        //进入下一层回溯
        backtrack(nums);
        //撤销选择
        track.removeLast();
    }
}

根据以上模板，让我们开始做题吧

78. 子集

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

（幂集）。

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

示例 1：
复制代码
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
复制代码
输入：nums = [0]
输出：[[],[0]]
提示：

1 <= nums.length <= 10

-10 <= nums[i] <= 10

nums 中的所有元素 互不相同

java 复制代码

class Solution {
    //子集问题属于组合问题的一种（看题目，这属于元素无重不可重复选问题）
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track  = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        if(nums.length == 0) return res;
        backtrack(nums,0);
        return res;
    }

    //无重不可复选回溯模板
    private void backtrack(int[] nums,int start){
        //base case
        res.add(new LinkedList<>(track));
        //回溯模板
        for(int i = start; i < nums.length; i ++){
            //做选择
            track.add(nums[i]);
            //进入下一层回溯
            backtrack(nums,i + 1);
            //撤销选择
            track.removeLast();
        }
    }
}

子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的

（幂集）。

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

示例 1：
复制代码
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
复制代码
输入：nums = [0]
输出：[[],[0]]
提示：

1 <= nums.length <= 10

-10 <= nums[i] <= 10

java 复制代码

class Solution {
    //分析一下，这属于元素可以重复但不可以复选的情况
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        //先排序
        Arrays.sort(nums);
        backtrack(nums,0);
        return res;
    }
    //回溯算法代码
    private void backtrack(int[] nums, int start){
        //base case
        res.add(new LinkedList<>(track));
        //核心模板
        for(int i = start; i < nums.length; i ++){
            //在做选择之前先剪枝
            if(i > start && nums[i] == nums[ i - 1]){
                continue;
            }
            //做选择
            track.add(nums[i]);
            //进入下一层回溯,这里不可以重复选择元素
            backtrack(nums,i + 1);
            //撤销选择
            track.removeLast();
        }
    }
}

组合总和 III

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9

每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:
复制代码
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。
示例 2:
复制代码
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。
示例 3:
复制代码
输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。
提示:

2 <= k <= 9

1 <= n <= 60

java 复制代码

class Solution {
    //这类问题属于元素不重不可复选的组合问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    //记录track的和
    int sum = 0;
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtrack(k,1,n);
        return res;
    }
    //回溯算法模板
    private void backtrack(int k, int start, int n){
        //base case
        if(sum == n && k == track.size()){
            res.add(new LinkedList<>(track));
            return;
        }
        if(sum > n){
            return;
        }
        //核心代码
        for(int i = start; i <=n; i ++){
            //做选择
            track.add(i);
            sum += i;
            //进入下一层回溯
            backtrack(k,i +1 ,n);
            //撤销选择
            sum -= i;
            track.removeLast();
        }
    }
}

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
输出: []
提示：

1 <= candidates.length <= 30

2 <= candidates[i] <= 40

candidates 的所有元素 互不相同

1 <= target <= 40

java 复制代码

class Solution {
    //这题属于元素不重但可以重复选择的组合问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    //记录track列表中的和
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtrack(candidates,0,target);
        return res;
    }
    //回溯核心代码
    private void backtrack(int[] candidates,int start, int target){
        //base case
        if(sum == target){
            res.add(new LinkedList<>(track));
            return;
        }
        if(sum > target){
            return;
        }
        //核心代码
        for(int i = start; i < candidates.length; i++){
            //做选择
            track.add(candidates[i]);
            sum += candidates[i];
            //进入下一层回溯
            backtrack(candidates,i,target);
            //撤销选择
            sum -= candidates[i];
            track.removeLast();
        }
    }
}

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]
]
提示:

1 <= candidates.length <= 100

1 <= candidates[i] <= 50

1 <= target <= 30

java 复制代码

class Solution {
    //分析：该题属于元素重复但不可以重复选择的组合问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    //用来记录track内的数字和
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //先排序，让相邻元素挨在一起
        Arrays.sort(candidates);
        if(candidates.length == 0) {
            return res;
        }
        backtrack(candidates,0,target);
        return res;
    } 

    //回溯代码
    private void backtrack(int[] candidates, int start,int target){
        //base case
        if(sum == target){
            res.add(new LinkedList<>(track));
            return;
        }
        //如果sum超出，停止回溯
        if(sum > target){
            return;
        }
        //核心代码
        for(int i = start; i < candidates.length; i ++){
            //在选择之前先剪枝
            if(i > start && candidates[i] == candidates[i - 1]){
                continue;
            }
            //做选择
            track.add(candidates[i]);
            sum += candidates[i];
            //进行下一层回溯
            backtrack(candidates,i+1,target);
            //撤销选择
            sum -= candidates[i];
            track.removeLast();
        }
    }
}

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：
复制代码
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：
复制代码
输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：
复制代码
输入：nums = [1]
输出：[[1]]
提示：

1 <= nums.length <= 6

-10 <= nums[i] <= 10

nums 中的所有整数 互不相同

java 复制代码

class Solution {
    //分析：该问题属于元素不重不可重复选的排列
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    //用来判断数字是不是用过了
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        backtrack(nums);
        return res;
    }
    //回溯代码
    private void backtrack(int[] nums){
        //base case
        if(track.size() == nums.length){
            res.add(new LinkedList<>(track));
            return;
        }
        //核心代码
        for(int i = 0; i < nums.length; i ++){
            //在选择之前先判断
            if(used[i]){
                continue;
            }
            //做选择
            track.add(nums[i]);
            used[i] = true;
            //进入下一次回溯
            backtrack(nums);
            //撤销选择
            used[i] = false;
            track.removeLast();
        }
    }

}

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：
复制代码
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：
复制代码
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：

1 <= nums.length <= 8

-10 <= nums[i] <= 10

java 复制代码

class Solution {
    //该题属于元素重复但不可以重复选的排列问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backtrack(nums);
        return res;
    }
    //回溯代码
    private void backtrack(int[] nums){
        //base case
        if(track.size() == nums.length){
            res.add(new LinkedList<>(track));
            return;
        }
        //核心代码
        for(int i = 0; i < nums.length; i ++){
            //剪枝
            if(used[i]){
                continue;
            }
            //精细剪枝，相同的值相邻的枝干不要
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1]){
                continue;
            }
            //做选择
            track.add(nums[i]);
            used[i] = true;
            //下一次回溯
            backtrack(nums);
            //撤回选择
            used[i] = false;
            track.removeLast();
        }
    }
}

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 <= n <= 20

1 <= k <= n

java 复制代码

class Solution {
    //分析：该问题属于元素不重复且不可重复选的组合问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n,1,k);
        return res;
    }
    //回溯代码
    private void backtrack(int n, int start, int k){
        //base case
        if(k == track.size()){
            res.add(new LinkedList<>(track));
            return;
        }
        //核心代码
        for(int i = start; i <= n; i ++){
            //做选择
            track.add(i);
            //进行下一次回溯
            backtrack(n,i+1,k);
            //撤销选择
            track.removeLast();
        }
    }
}

<>(track));

return;

}

//核心代码

for(int i = 0; i < nums.length; i ++){

//剪枝

if(used[i]){

continue;

}

//精细剪枝，相同的值相邻的枝干不要

if(i > 0 && nums[i] == nums[i - 1] && used[i - 1]){

continue;

}

//做选择

track.add(nums[i]);

used[i] = true;

//下一次回溯

backtrack(nums);

//撤回选择

used[i] = false;

track.removeLast();

}

复制代码

>[77. 组合](https://leetcode.cn/problems/combinations/)
>
>给定两个整数 `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 <= n <= 20`
>- `1 <= k <= n`

```java
class Solution {
    //分析：该问题属于元素不重复且不可重复选的组合问题
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n,1,k);
        return res;
    }
    //回溯代码
    private void backtrack(int n, int start, int k){
        //base case
        if(k == track.size()){
            res.add(new LinkedList<>(track));
            return;
        }
        //核心代码
        for(int i = start; i <= n; i ++){
            //做选择
            track.add(i);
            //进行下一次回溯
            backtrack(n,i+1,k);
            //撤销选择
            track.removeLast();
        }
    }
}