回溯算法1

习题：46. 全排列 - 力扣（LeetCode） (leetcode-cn.com)

大致思路：

1.每个元素都会走

以第一个元素为path路径第一个数，递归进行，一直得到path的size=数组的大小，将其添加到结构集当中，之后递归返回。注意变量的值，回溯处理，移除最后的元素（恢复之前的状态），123为例子，

123第一次退回来，添加3时候for循环的i为2，退回来就删除一个元素，之后再退，退到12状态，接着quanpai（）方法之后执行，删除最后一个元素，path只有一个元素1，当前i=1<arr.length，再将i=2的元素加入，此时path为13，之后再递归将2加入。

之后退回第一步，i=1，最开始i=0，进行操作，path值开始为2。。。。。

package com.yzc.sc;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author YZC
 * @Date 2022/3/8/12:55
 */
public class QuanPairite {
    static ArrayList<List<Integer>> result = new ArrayList<>();
    static LinkedList<Integer> path = new LinkedList<>();

    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        quanpai(arr);
        System.out.println(result);

    }

    public static void quanpai(int[] arr) {
        if (path.size() == arr.length) {   //如果路径等于数组元素的长度，将结果集放回到result
            result.add(new ArrayList<>(path));
            return;   //递归结束条件
        }
        for (int i = 0; i < arr.length; i++) { //遍历每一个元素,之后走的是添加其他元素
            if (path.contains(arr[i])) {
                continue;
            }
            path.add(arr[i]);
            quanpai(arr);  //递归进行添加元素     重新走for循环，如果元素存在，跳过，添加path不存在的元素
            path.removeLast();//回溯操作，移除元素，类似二叉树的返回上一个节点
        }
//      递归进行，注意每次的变量值，可能还会重新走流程

    }

}

2.

216. 组合总和 III

216. 组合总和 III - 力扣（LeetCode） (leetcode-cn.com)

 

难度中等431收藏分享切换为英文接收动态反馈

找出所有相加之和为 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
没有其他符合的组合了。

package JZ.ss;

import java.util.ArrayList;
import java.util.List;

/**
 * @author YZC
 * @Date 2022/3/8
 */
class LC216 {
  //基本实现思路：  回溯
//    确定终止条件，k个数和为n    1---9     k2, n5
//    当path中有两个元素，判断和sum和n是否相等，相等就放入结果集
//
// 注意for循环：
//     第一次进入，加入path，和操作，之后递归i+1元素进行相加，
//          递归第二个数加入path，判断，如果sum！=n，进行回归，并将path及sum恢复之前状态
//          1和其他的数字都走完一遍，i+1，进行2和其他的数字进行组合
//

    public static void backTracking(int k, int n, List<List<Integer>> res, List<Integer> cur, int num, int sum) {
        if (sum > n) {  //剪枝
            return;
        }if (cur.size() == k) {
            if (sum == n) {
                res.add(new ArrayList<>(cur));
            }
            return;
        }
        for (int i = num; i <= 9; i++) {
            cur.add(i);
            sum += i;

            backTracking(k, n, res, cur, i + 1, sum);

            cur.remove(cur.size() - 1);
            sum -= i;

        }
    }

    public static List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> cur = new ArrayList<>();
//        back(k, n, res, cur, 1, 0);
        backTracking(k, n, res, cur, 1, 0);
        return res;
    }

    public static void main(String[] args) {
//        System.out.println(combinationSum3(2, 5));
        System.out.println(combinationSum3(2, 5));
    }




}