最近刷面试题经常刷到递归方面的算法，一直以为都是递归，后来发现竟然都有具体的叫法，所以写了这篇博客来牢记以下
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);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
