java——递归（动态规划，回溯）
最近刷面试题经常刷到递归方面的算法，一直以为都是递归，后来发现竟然都有具体的叫法，所以写了这篇博客来牢记以下
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); } }
