回溯算法框架

回溯算法

嗯，这个问题怎么说呢，就是字面意思，通过回退来求解所有结果从而达
到目的，主要有三个要素需要知道
1.路径
2.选择列表
3.判定结束条件

1.全排列问题

1.路径：已经排好序的数组
2.选择列表：接下来可以选择的列表
3.判定结束条件：排好一组数的序列

package m.reback;

import java.util.LinkedList;

/*全排列问题*/
public class AllSort {
    //用来存储每一个排列的顺序
    private static LinkedList<LinkedList<Integer>> linkedLists = new LinkedList<LinkedList<Integer>>();
    public static void main(String[] args) {
        //用来作为存储的列表
        LinkedList<Integer> linkedList = new LinkedList<>();
        int[] num = {1,2,3};
        track(linkedList,num);
        for (LinkedList<Integer> l:linkedLists
             ) {
            for (int i:l
                 ) {
                System.out.print(i+" ");
            }
            System.out.println("");
        }
    }

    private static void track(LinkedList<Integer> linkedList, int[] num) {
        //判断结束条件返回
        if (linkedList.size() == num.length){
            //将这一条全排列数据存储
            linkedLists.add(linkedList);
            for (int i:linkedList
            ) {
                System.out.print(i+" ");
            }
            System.out.println("");
            return;
        }
        //对接下来还没加入的数字进行排列
        for (int i = 0; i < num.length; i++) {
            //如果是无效数据就返回下一条
            if (linkedList.contains(num[i])){
                continue;
            }
            //将数据添加到全排列中
            linkedList.add(num[i]);
            //继续进行接下来的数据排列
            track(linkedList,num);
            //数据回退一位，进行下一位的全排列
            linkedList.removeLast();
        }
    }
}

2.N皇后问题

 给你⼀个 N×N 的棋盘，让你放置 N 个 皇后，使得它们不能互相攻击。
 PS：皇后可以攻击同⼀⾏、同⼀列、左上左下右上右下四个⽅向的任意单位
 Think:把n行分别想成n个皇后可以呆的位置，n列想成皇后分别可以呆的位置，所以又是一个回溯算法

package m.reback;

import java.util.LinkedList;

public class NQueen {
    private static LinkedList<LinkedList<Integer>> lists = new LinkedList<>();
    public static void main(String[] args) {
            LinkedList<Integer> list = new LinkedList<>();
            int N = 4;
            track(list,N);
    }

    private static void track(LinkedList<Integer> list, int n) {
        //达到返回条件
        if (list.size() == n){
            System.out.println(list);
            lists.add(list);
            return;
        }
        //将剩余皇后进行全排列
        for (int i = 0; i < n; i++) {
            //判断接下来的位置放皇后合法不合法
            if (!isTrue(list,i)){
                continue;
            }
            //将第list.length()个皇后的位置放置
            list.add(i);
            //进行下一个皇后的位置进行放置
            track(list,n);
            //将最后一个皇后删除，看一下其他皇后
            list.removeLast();
        }
    }

    private static boolean isTrue(LinkedList<Integer> list, int position) {
        //判断同一列
        if (list.contains(position)){
            return false;
        }

        for (int i = 0; i < list.size(); i++) {
            //判断左上角
            if ((list.size()-position) == (i - list.get(i))){
                return false;
            }
            //判断右上角
            if ((list.size()+position) == (i + list.get(i))){
                return false;
            }
        }


        return true;
    }

}