回溯算法

一、迭代算法基本模型
1、定义k代表行数或者深度，即节点的位置。
2、用一个数组a[i]表示每个节点值的可能性。
3、父节点选择一种状态值，遍历子节点中所有值。符合全部条件则输出，符合部门条件，则继续遍历，如果遍历结束，还不符合则恢复初始值，且返回上一层（–k）
4、主要三个方法：主要方法，检查条件方法，输出方法
5、伪代码如下样式

//1、定义节点个数
int k=0;
//定义一个数组，且初始化数组
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
    a[i] = -1;
}
while (k >= 0) {
            while (a[k] +1< n) {
                a[k]++;
                //一个节点轮询结束
                if (check(a, k)) {
                    if (k == n - 1) {
                        //完全符合条件，输出
                    } else if(k<n){
                        //部分条件符合（还没有执行到底）
                        k++;
                    }
                }
            }
            //不符合条件，则返回
            a[k] = -1;
            k--;
}

二、实战
1、组合求和
1.1 题目描述（来源LeetCode）：
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-ii
1.2 迭代解法

public static List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<>();
        //节点开始位置
        int k=0;
        int len=candidates.length;
        //初始化所有节点的值
        int[] a=new int[len];
        for(int i=0;i<len;i++){
            a[i]=-1;
        }
        //排序
        Arrays.sort(candidates);

        while(k>=0){
            //取值范围（0或者1）
            while(a[k]<1){
                a[k]++;
                //检查结论是否符合条件
                int sum =check(a,candidates,k);
                if(sum==target){
                    List<Integer> temp=print(a,candidates);
                    //判读是否已经存在
                    Boolean existFlag=true;
                    for(int j=0;j<result.size();j++){
                        List<Integer> exist=result.get(j);
                        if(exist.equals(temp)){
                            existFlag=false;
                        }
                    }
                    if(existFlag){
                        result.add(temp);
                    }
                }else if(sum <target&& k<len-1) {
                    //遍历未结束，但符合局部结论
                    k++;
                }
            }
            //回滚
            a[k]=-1;
            k--;
        }
        return result;
    }
    public static List<Integer> print(int[] a,int[] candidates){
        List<Integer> tempList=new ArrayList<>();
        for(int i=0;i<a.length;i++){
            if(a[i]==1){
                tempList.add(candidates[i]);
            }
        }

        return tempList;
    }
    public static int check(int[] a,int[] candidates,int k){
        int sum=0;
        for(int i=0;i<=k;i++){
            if(a[i]==1){
                sum+=candidates[i];
            }
        }

        return sum;
    }

2、N皇后问题
2.1 题目描述（来源Leetcode）
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-queens

2.2 解法

 public static List<List<String>> solveNQueens(int n) {
        List<List<String>> result = new ArrayList<>();
        int count = 0;
        int k = 0;
        int[] a = new int[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = -1;
        }
        //a[n]={0,1,2,3,4,5...n-1}
        while (k >= 0) {
            while (a[k] +1< n) {
                a[k]++;
                //一个节点轮询结束
                if (check(a, k)) {
                    if (k == n - 1) {
                        //完全符合条件，输出
                        count++;
                       
                        List<String> row=  print(a,n);
                        result.add(row);
        
                    } else if(k<n){
                        //部分条件符合（还没有执行到底）
                        k++;
                    }
                }
            }

            //不符合条件，则返回
            a[k] = -1;
            k--;

        }
        return result;
    }
     public static List<String> print(int[] a,int n) {
        List<String> str=new ArrayList<>();

        String[] strArray=new String[n];
        for (int i = 0; i < a.length; i++) {
            StringBuilder  b=new StringBuilder();
            for (int j = 0; j < a.length; j++) {
                b.append(".");
            }

            strArray[i]=b.toString();
        }
        for (int j = 0; j < a.length; j++) {
            int cow=a[j];
            StringBuilder  b=new StringBuilder(strArray[j]);
            b.replace((cow),(cow+1),"Q");
            strArray[j]=b.toString();
        }

        for (int i = 0; i <a.length; i++) {
            str.add(strArray[i]);
        }

       
        return str;
    }
    public static Boolean check(int[] a, int loc) {
        for (int i = 0; i < loc; i++) {
            if (a[i] == a[loc]||(Math.abs(a[loc]-a[i])==loc-i)) {
                return false;
            }
        }
        return true;
    }