java——递归（动态规划，回溯）

Posted 2020-10-04 东木刀纹

最近刷面试题经常刷到递归方面的算法，一直以为都是递归，后来发现竟然都有具体的叫法，所以写了这篇博客来牢记以下

1. 五大常用算法

(1) 分治算法

把一个复杂的问题分成两个或多个相同或者相似的子问题，然后不断地细分，直到最后的子问题可以很简单地求解出来，原问题的解就是自问题的合并。比如常见的快速排序算法和归并算法

分治法的核心思想就是把大的难解的问题不断分割，分而治之。

(2) 动态规划

类似于分治法，将带求解的问题分化成几个小问题，每个小问题的解会影响原问题的解。

先求每个子问题的局部解，然后通过决策保留那些可能达到最优解的局部解

能够分解成若干子问题，且子问题之间有交叉

(3) 回溯算法

类似于一个枚举的过程，其实也是一个建树的过程，是树的深度优先搜索。

在搜索尝试过程中，发现当前节点已经不能满足求解条件时，就返回其父节点，继续尝试别的路径

(4) 分支界限法

类似于回溯算法，不过不是深度优先搜索，而是广度优先搜索，一般是用到queue（先进先出）来对每一个节点进行判断。

(5) 贪心算法

在问题求解时，总是找到局部最优解，而不是整体上最优。

贪心算法的前提：局部最优策略能最终产生全局的最优解

 

2. 递归（个人感觉这个学会了，算法只是如何调用递归）

先上一个最简单的递归代码，斐波那契数列

public class Fibo {
    public int[] array = new int[100];{
        array[0]=0;
        array[1]=1;
        array[2]=1;}
    
    public int Fibonacci(int n){
        if(n==1||n==2){
            return 1;
        }else{
            return this.array[n]=Fibonacci(n-1)+Fibonacci(n-2);
        }
        
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fibo fb = new Fibo();
        System.out.println(fb.Fibonacci(3));

    }

}

当然，也可以来个伪递归，就是建立一个数组，把答案先预存起来，然后直接返回结果。剑指offer上很多直接递归是通不过的，必须要伪递归才可以

再来个青蛙跳台阶的代码，题目同样是剑指offer上的

//一只青蛙一次可以跳上1级台阶，也可以跳上2级。
//求该青蛙跳上一个n级的台阶总共有多少种跳法

public class JumpFloor {
    
    public int Jump(int target){
        if(target==0){
            return 0;
        }else if(target==1){
            return 1;
        }else if(target==2){
            return 2;
        }else{
            int[] array = new int[target+1];
            array[0]=0;
            array[1]=1;
            array[2]=2;
            for(int i=3;i<array.length;i++){
                array[i]=array[i-1]+array[i-2];
            }
            return array[target];
        }
        
    }
    
    //一只青蛙一次可以跳上1级台阶，也可以跳上2级，跳3个，4个......n-1个。
    //求该青蛙跳上一个n级的台阶总共有多少种跳法
    public int JumpII(int target){
        if(target==0){
            return 0;
        }else if(target==1){
            return 1;
        }else if(target==2){
            return 2;
        }else{
            int[] array = new int[target+1];
            array[0]=0;
            array[1]=1;
            array[2]=2;
            int sum = 3;
            for(int i=3;i<array.length;i++){
                array[i]=sum+1;
                sum = sum+array[i];
            }
            return array[target];
        }
        
    }
    


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        JumpFloor jf = new JumpFloor();
        System.out.println(jf.Jump(3));
        System.out.println(jf.JumpII(3));

    }

}

这里也是用伪递归来实现的

 

3. 递归的本质

其实递归的本质就是找到前后的联系，找到递归的公式

例如    F(n) = F(n-1) + F(n-2) 等等

 递归的一般情况是

(1). if（满足递归结束条件），返回值

(2). else，继续递归

 

4. 回溯的本质，其实是在递归基础上进行了改进

(1). if（不满足继续递归查找的条件，通常是界限判断），返回

(2). if（满足查找条件），记录下来，继续往下

(3). 加入这个节点，更新条件和值

(4). 递归左边

(5).递归右边

(6). 删除这个节点（回溯）

来个例子，例子是中兴的一道笔试题，我对其进行了改进。其实所有这类的能量补给，血条补给都是相同的解法。

import java.util.ArrayList;

//输入
//补给站个数，[补给站距离]，[补给站能量]，目的地距离（总共需要能量），初始能量
//3, [5, 7, 10], [2, 3, 5], 15, 5
//5, [10, 20, 22, 23, 26], [10, 2, 5, 1, 1], 30, 10
//输出
//所有可以到达的方案，到达不了返回-1



import java.util.Arrays;

import java.util.Scanner;

public class PowerGain {
    
    private ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();
    private ArrayList<Integer> list = new ArrayList<Integer>();
    
    public ArrayList<ArrayList<Integer>> minNumber(int n, int[] distince, int[] judce, int left, int right, int destination, int power){
        //System.out.println(left+" "+destination+" "+power);
        if( left>right || power<=0){
            return listAll;
        }
        
        //if(power>=distince[left]){
            list.add(left);
        //}
        
        
        if(power>=destination){
            listAll.add(new ArrayList<Integer>(list));
            //return listAll;
        }
        
        int newleft = left+1;
        //不喝继续前行,喝了继续前行
        minNumber(n, distince, judce, newleft, n, destination-distince[left], power-distince[left]);
        minNumber(n, distince, judce, newleft, n, destination-distince[left], power-distince[left]+judce[left]); 
        list.remove(list.size()-1);
        return listAll;


    }
    
    public void outPrint(ArrayList<ArrayList<Integer>> tempAll){
        if(tempAll.size()==0){
            System.out.println(-1);
            return;
        }
        for(int i=0;i<tempAll.size();i++){
            ArrayList<Integer> temp = tempAll.get(i);
            for(int j=1;j<temp.size();j++){
                System.out.print(temp.get(j));
                if(j!=temp.size()-1){
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
    
    
    
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        String st = input.nextLine();
        String[] sarray = st.split(", ");
        int n = Integer.parseInt(sarray[0]);
        
        int[] distince = new int[n+1];
        int[] judce = new int[n+1];
        int index = 1;      //sarray下标
        for(int i=0;i<n;i++){
            if(i==0){
                distince[i] = Integer.parseInt(sarray[index].substring(1));
                judce[i] = Integer.parseInt(sarray[index+n].substring(1));
            }else if(i==n-1){
                distince[i] = Integer.parseInt(sarray[index].substring(0, sarray[index].length()-1));
                judce[i] = Integer.parseInt(sarray[index+n].substring(0, sarray[index+n].length()-1));

            }else{
                distince[i] = Integer.parseInt(sarray[index]);
                judce[i] = Integer.parseInt(sarray[index+n]);

            }
            index++;
        }
        index = 2*n+1;
        int destination = Integer.parseInt(sarray[index]);
        int power = Integer.parseInt(sarray[index+1]);
        
        //长度分段
        judce[n] = 0;
        distince[n]=destination-distince[n-1];
        for(int i=n-1;i>0;i--){
            distince[i]=distince[i]-distince[i-1];
        }
        
        PowerGain m = new PowerGain(){};

            
        ArrayList<ArrayList<Integer>> result = m.minNumber(n, distince, judce, 0, n, destination, power);
        m.outPrint(result);
        
            
    }

}