经典算法题

约瑟夫问题

也叫丢手绢问题, 就是一群人围成一个圈, 然后数数, 数到一个数的人出来,问出来的人的顺序

思路
整体的思路就是用一个环形的单链表, 从头结点开始计数, 比方说计到2的节点删除, 输出一个删除的顺序.
代码

/**
 * 约瑟夫问题
 */
public class Test05 {
    public static void main(String[] args) {
        CycleLinkedList linkedList = new CycleLinkedList();
        linkedList.addNodes(5);

        linkedList.listNodes();
        System.out.println("------------------");
        linkedList.popNodes();
    }
}

/**
 * 链表
 */
class CycleLinkedList {

    private CycleLinkedNode first = null;

    /**
     * @param nums 添加 nums 个节点
     */
    public void addNodes(int nums) {
        CycleLinkedNode tmp = null;
        for (int i = 1; i <= nums; i++) {
            if (i == 1) {
                first = new CycleLinkedNode(i);
                tmp = first;
            } else if (i == nums) {
                CycleLinkedNode endNode = new CycleLinkedNode(i);
                endNode.setNext(first);
                tmp.setNext(endNode);
            } else {
                CycleLinkedNode curNode = new CycleLinkedNode(i);
                tmp.setNext(curNode);
                tmp = curNode;
            }
        }
    }

    /**
     * 遍历一下节点
     */
    public void listNodes() {
        if (Objects.isNull(first)) {
            System.out.println("空的");
            return;
        }

        CycleLinkedNode temp = first;
        while (true) {

            System.out.println(temp.getNo());
            temp = temp.getNext();

            if (temp == first) {
                break;
            }
        }
    }


    /**
     * 按照假定的顺序取出节点 (我这里写死了2)
     */
    public void popNodes() {
        if (Objects.isNull(first)) {
            System.out.println("空的");
            return;
        }

        int count = 1;

        CycleLinkedNode temp = first;
        CycleLinkedNode pre = first;
        while (true) {
            if (Objects.isNull(temp)) {
                break;
            }
            if (count == 2) {
                System.out.println("输出的元素 :  " + temp.getNo());
                pre.setNext(temp.getNext());
                temp.setNext(null);
                temp = pre.getNext();
                count = 1;
            } else {
                pre = temp;
                temp = temp.getNext();
                count++;
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 链表的节点
 */
class CycleLinkedNode {
    private int no;
    private CycleLinkedNode next;

    public CycleLinkedNode(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public CycleLinkedNode getNext() {
        return next;
    }

    public void setNext(CycleLinkedNode next) {
        this.next = next;
    }
}

运行结果如下:

迷宫问题

假设我们有这么一个迷宫, 需要找到从起始位置到终点位置的一条路线

思路 我们可以用一个二维的数组来模拟这么一个迷宫, 数组里的 0 代表未走过, 1代表是墙, 2 代表这条路线已经走过了, 3代表这个是条死路
使用递归回溯算法来进行寻找路的一个过程
代码

**
 * 迷宫问题
 */
public class MiGong {
    public static void main(String[] args) {
        //定义一个8*7的二维数组
        int[][] map = new int[8][7];
        //给初始二维数组赋值, 把墙给赋好值
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][1] = 1;
        map[3][2] = 1;
        map[2][2] = 1;

        //遍历一下
        System.out.println("找迷宫之前的地图-------------");
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println("搜索之后的地图--------------");
        findWay(map, 1, 1);

        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
    }

    /**
     * 终点坐标 (6 ,5)
     *
     * @param map 地图的二维数组
     * @param i   初始横坐标
     * @param j   初始纵坐标
     * @return 返回是否可以走这个点
     * 约定数组里面, 1 代表墙 , 0 代表没有走过, 2 代表走过, 3代表这个点不通
     * 找路的规则 , 先判断下可不可以走, >>>  判断右 >>>判断上  >>>> 判断左 如果都不能走, 则回溯
     */
    public static boolean findWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) { // 递归的出口
            return true;
        } else {
            if (map[i][j] == 0) { // 如果这个点没有走过, 则开始判断这个点周围的路
                                    // 否则直接返回false

                //假设该点可以走通 , 先置为 2
                map[i][j] = 2;
                if (findWay(map, i + 1, j)) { //递归调用下这个方向
                    return true;
                } else if (findWay(map, i, j + 1)) {//递归调用右这个方向
                    return true;
                } else if (findWay(map, i - 1, j)) {//递归调用上这个方向
                    return true;
                } else if (findWay(map, i, j - 1)) {//递归调用左这个方向
                    return true;
                } else {//都不能走的话置为 3

                    map[i][j] = 3;
                    return false;
                }
            } else {
                return false;
            }
        }
    }
}

运行结果

死亡八皇后问题

一个很古老的问题, 该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

• 第一个皇后先放第一行第一列
• 第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
• 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
• 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
• 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列

**代码实现: **

public class Dead8Queen {

    int max = 8;
    int[] array = new int[max];
    static int count = 0;

    public static void main(String[] args) {
        Dead8Queen dead8Queen = new Dead8Queen();

        dead8Queen.printQueen(0);

        System.out.println("总共解法:" + count);
    }

    // 每一次递归时，进入到printQueen中都有  for(int i = 0; i < max; i++)，因此会有回溯
    private void printQueen(int n) {
        //如果已经放置满了8个皇后则结束方法
        if (n == max) {
            print();
            return;
        }

        for (int i = 0; i < max; i++) {
            array[n] = i; //将皇后放在第N个位置上
            if (!check(n)) { //判断是否会发生冲突
                printQueen(n + 1); //递归调用
            }
            //有冲突会继续检查下一个位置

        }
    }

    /**
     * @return 返回皇后是否发生冲突
     */
    private boolean check(int n) {
        for (int i = 0; i < n; i++) {

            //1. array[i] == array[n]  表示判断 第n个皇后是否和前面的n-1个皇后在同一列
            //2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
            // n = 1  放置第 2列 1 n = 1 array[1] = 1
            // Math.abs(1-0) == 1  Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
            //3. 判断是否在同一行, 没有必要，n 每次都在递增
            if (array[n] == array[i] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return true;
            }
        }
        return false;
    }

    //写一个方法，可以将皇后摆放的位置输出
    private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

运行结果: