暴力递归1

暴力递归的思路：
　　利用递归的(深度优先)搜索功能，去枚举一个问题的所有可能情况(或步骤)，从而寻求最优解(总答案)

 

1.汉诺塔问题

* 将问题分为三个步骤，使用递归的方式进行实现。
* 定义一个函数f(from,to,other),from表示圆盘移动的起始杆,to表示圆盘移动的终点杆,other为另一个杆
*
* 递归的思路：
* 1.将上方的1——i-1个圆盘从左圆盘移动到中间圆盘
* 2.将最下方的第i个圆盘从左圆盘移动到右圆盘
* 3.将1——i-1个圆盘从中间圆盘移动到右圆盘

 

代码及解析：

public static void f(int i,String from,String to,String other) {//i表示第几个圆盘
        if (i == 1) {
            System.out.println("Move 1 from " + from + " to " + to);
        }
        else {
            f(i - 1,from,other,to);
            System.out.println("Move " + i + " from " + from + " to " + to);
            f(i - 1,other,to,from);
        }
    }
    
    public static void hanoi(int n) {
        if (n > 0) {
            f(n,"左","中","右");
        }
    }
    
    public static void main(String[] args) {
        hanoi(5);
    }

 

2.获得并打印输出一个字符串的所有子字符串

* 思路：采用暴力递归
* 对每个字符是否要打印都进行递归式的暴力搜索遍历即可

代码及解析：

//法一(较为占用空间)
    public static void process1(char[] str,int i,List<Character> res) {
        if (i == str.length) {
            System.out.println(res);
            return;
        }
        List<Character> resKeep = copyList(res);//保留所有的字符
        resKeep.add(str[i]);
        process1(str,i + 1,resKeep);//遍历所有要打印字符的路线
        List<Character> resNoInclude = copyList(res);
        process1(str,i + 1,resNoInclude);//遍历所有不打印字符的路线
    }
    
    public static List<Character> copyList(List<Character> res) {
        List<Character> ans = new ArrayList<>();
        for (Character c : res) {
            ans.add(c);
        }
        return ans;
    }
    
    //法二(重复利用空间)
    public static void process2(char[] str,int i) {
        if (i == str.length) {
            System.out.println(String.valueOf(str));
            return;
        }
        char tmp = str[i];
        process2(str,i + 1);//保留当前位置的字符的路线
        str[i] = 0;//将该位   置为空
        process2(str,i + 1);//舍弃当前位置的字符的路线
        str[i] = tmp;//复原原来的字符串
    }

 

3.字符串全排列：

* 暴力递归思想：
* 从第一个字符串开始，可以与后面的任意字符进行交换，交换后再对第二个字符串进行类似的操作，
* 以此类推，直到最后一个字符串，即可得到所有的排列可能

代码及解析：

public static ArrayList<String> AllSort(String str) {
        char[] strs = str.toCharArray();
        ArrayList<String> res = new ArrayList<>();
        process(strs,0,res);
        return res;
    }
    
    public static void process(char[] str,int i,ArrayList<String> res) {
        if (i == str.length) {
            res.add(String.valueOf(str));
            return;
        }
        boolean[] isVisit = new boolean[26];
        for (int j = i; j < str.length; j++) {
            if (!isVisit[str[j] - 'a']) {//避免出现重复排序的情况
                isVisit[str[j] - 'a'] = true;
                swap(str,i,j);//进行遍历交换，得到所有可能的全排列
                process(str,i + 1,res);
                swap(str,i,j);//恢复回交换前的状态
            }
        }
    }
    
    public static void swap(char[] str,int i,int j) {
        char tmp = str[i];
        str[i] = str[j];
        str[j] = tmp;
    }

 

4.两端取数问题：

　　A和B两人在数组的两端取数(A先B后)，若两者都做最优的选择，返回两者取到的数的总和的最大值

代码及解析：

public static int win1(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        return Math.max(f(arr,0,arr.length - 1), s(arr,0,arr.length - 1));
    }
    
    public static int f(int[] arr,int L,int R) {//先手者(A)的操作函数
        if (L == R) {//如果只剩一个数则直接取走
            return arr[L];
        }
        //先手者有主导权，可以控制自己拿到最好情况(即max)
        return Math.max(arr[L] + s(arr,L + 1,R), arr[R] + s(arr,L,R - 1));
    }
    
    public static int s(int[] arr,int L,int R) {//后手者(B)的操作函数
        if (L == R) {
            return 0;
        }
        //因为后手者的选择被先手者控制，所以它只能取到自己的最坏情况(即min)
        return Math.min(arr[L] + f(arr,L - 1,R), arr[R] + f(arr,L,R - 1));
    }

 

5.递归实现栈的逆序：
* 在使用递归时，要注意每次得取到栈底的元素，才可以实现栈的逆序，所以要先写一个获得栈底元素的方法

代码及解析：

public static void reverse(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            return;
        } 
        int i = f(stack);//i为栈底元素
        reverse(stack);
        stack.push(i);//将栈底的元素压入到栈中
        //所以越在底部的元素会越早被取出，也就会被越迟压入栈，所以最底部的元素最终被调整到最顶部。
    }
    
    public static int f(Stack<Integer> stack) {//将栈中最底下的元素弹出，并保持栈的原始数据位置
        int rst = stack.pop();
        if (stack.isEmpty()) {
            return rst;
        } else {
            int last = f(stack);
            stack.push(last);
            return last;
        }
    }