回溯问题

八皇后问题

 //放置第k个皇后
    static void f(int[] array,int k){

        //边界条件：直到八个皇后放置完成，显示解
        if(k==8){
            show(array);
            return;
        }

        for (int i=0;i<8;i++){
            array[k]=i;  //有八列可以放置，逐一的试探
            if(check(array,k,i)){  //如果可以第i列放置,则放置第k+1个皇后
                f(array,k+1);
            }
            //如果导致了冲突，则不能继续执行放下一个皇后，则说明前面放置的有问题，返回上一层递归继续试探
        }
    }

    private static void show(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);

        }
        System.out.println();
    }

    //检查新皇后放入后是否冲突
    private static boolean check(int[] array, int row, int cal) {
        //对该行以上的行进行检验，不用检验横向冲突，因为每行只有一个皇后
        for (int i = 0; i < row; i++) {
            //检验在纵向上有没有冲突
            //本行皇后所放置的列号cal等于前面第i个皇后所放置的列号array[i]说明冲突了
            if(array[i]-cal==0){
                return false;
            }
            //检验对角有没有冲突，如果两个皇后横向差等于纵向差则说明有冲突
            if(row-i==Math.abs(array[i]-cal)){
                return false;
            }
        }
        return true;
    }

回溯求解字符串排序问题

    static ArrayList<String> handle(String str){
        ArrayList<String> strings = new ArrayList<>();
        if(str.length()==0){
            return strings;
        }
        if(str.length()>9){
            return strings;
        }
        if(str.length()==1){
             strings.add(str);
             return strings;
        }
        char[] chars = str.toCharArray();
        find(strings,chars,0);
        Collections.sort(strings);
        return strings;
    }

    //让第i个元素作为第一个元素，与其他元素交换位置
    private static void find(ArrayList<String> strings, char[] chars, int i) {
        if(i==chars.length){
            return;
        }
        if(!strings.contains(String.valueOf(chars))){
            strings.add(String.valueOf(chars));
        }
        for (int j = 0; j < chars.length; j++) {
            if(chars[i]!=chars[j]){
                swap(chars,i,j);
                //把新生成的char转换成字符串加入字符串数组 ,如果已经有了就不加入
                if(!strings.contains(String.valueOf(chars))){
                    strings.add(String.valueOf(chars));
                }
                //将第i的下一个元素作为第一个元素，与其他元素交换位置
                find(strings,chars,i+1);
                swap(chars,i,j);  //如果交换失败就原换回来，进行下一次交换
            }else if(!strings.contains(String.valueOf(chars))){
                strings.add(String.valueOf(chars));
            }
        }
    }

    //交换两个元素位置
    private static void swap(char[] chars,int i,int j){
        char tmp=chars[i];
        chars[i]=chars[j];
        chars[j]=tmp;

    }