复杂度的认识（斐波那契函数）和练习题(打家劫舍使用的是动态规划了，和递归的优化)

斐波那契函数

在这个里面的复杂度为O(2^n)，会有大量的重复计算，fib(2)就调用了3次，fib(1)就调用了4次。

public static int fib(int n) {
	if(n<=1) return n;
	return fib(n-1)+fib(n-2);
}

**1：**HashMap 保存，我们用数组来保存把，把 n 作为我们的数组下标，f(n) 作为值，例如 arr[n] = f(n)。f(n) 还没有计算过的时候，我们让 arr[n] 等于一个特殊值，例如 arr[n] = -1。

当我们要判断的时候，如果 arr[n] = -1，则证明 f(n) 没有计算过，否则， f(n) 就已经计算过了，且 f(n) = arr[n]。直接把值取出来就行了。代码如下：

1// 我们实现假定 arr 数组已经初始化好的了。
public class _斐波那契_ {
	static int n;
	static int [] arr;
	public int f(int n){
		    if(n <= 1){
		       return n;
		   }
		    if(arr[n]>1){	    	//已经计算好的直接返回。
		    	return arr[n];
		    }
		    else{		        // 没有计算过，递归计算,并且把结果保存到 arr数组里
		        arr[n] = f(n-1) + f(n-2);
		        return arr[n];
		    }
		}
	public static void main(String[] args) {
		Scanner x=new Scanner(System.in);
		System.out.println("请输入要求的数：");
		n=x.nextInt();
		arr=new int[n+1];
		_斐波那契_ w =new _斐波那契_();
//		for(int i=0;i<20;i++) {
//			arr[i]=-1;
//		}
		int y=w.f(n);
		System.out.println("得到的结果为：");
		System.out.println(y);
	}
}

也就是说，使用递归的时候，必要
须要考虑有没有重复计算，如果重复计算了，一定要把计算过的状态保存起来。
这里的解释图：他是先遍历f（n-1）的，后返回数组arr[n],是当在第一次递归遍历完全后在f(n-1)在返回指的路上在进行对f（n-2）的递归，f(n-1)是从n-1到0，而f(n-2)是从0到n-2的返回，当再次在递归f（n-2）的时候此时当遍历f(n-1)的时候数组都附上所求的值了，当在此用的时候就直接用返回数组就可以了，这样也就避免了重复加载。

2. 考虑是否可以自底向上，这种方法，也被称为递推。

对于递归的问题，我们一般都是从上往下递归的，直到递归到最底，再一层一层着把值返回。

不过，有时候当 n 比较大的时候，例如当 n = 10000 时，那么必须要往下递归10000层直到 n <=1 才将结果慢慢返回，如果n太大的话，可能栈空间会不够用。

对于这种情况，其实我们是可以考虑自底向上的做法的。例如我知道

f(1) = 1;

f(2) = 2;

那么我们就可以推出 f(3) = f(2) + f(1) = 3。从而可以推出f(4),f(5)等直到f(n)。因此，我们可以考虑使用自底向上的方法来取代递归，代码如下：
在这里面的方式主要运用了关于如何
下面的斐波那契实现的代码的复杂度为：O(n)

public static int fib(int n) {
	if(n<=1) return n;
	int first=0;
	int second=1；
	for(int i=0;i<n;i++) {
		second+=first;
		first=second-first;
	}
	return second;
}

大概计算复杂度。

在下面这个代码的复杂度为1+3n,判断和执行都算的，在这里我们先进行对i初始化算一次，每次都会判断i<n,这样执行n次，在i++也会执行n次，在System.out.println(“test”);这里执行了n次，所以总共步奏执行了1+3n次了。

public static void test2(int n) {
	for(int i=0;i<n;i++) {
		System.out.println("test");
	}
}

在这里面方法的复杂度是1+2n+n+3nn,因为在第一个for循环中会执行1+2n次在第二个for循环中会执行n次，所以第二个for就是运行n(1+3n)次，

public static void test3(int n) {
	for(int i=0;i<n;i++) {
		for(int j=0;j<n;j++) {
			System.out.println("test");
		}
	}
}

在这里里面的复杂度为
1+2n+n*(1+45)
1+2n+46n
48n+1,

public static void test3(int n) {
	for(int i=0;i<n;i++) {
		for(int j=0;j<15;j++) {
			System.out.println("test");
		}
	}
}

在下面的代码中是经历的是log5（n）次

public static void test(int n) {
	while((n=n/5)>0) {
		System.out.println("test");
	}
}

在这下面的代码是1+2log2(n)+log2(n)(1+3n)

public static void test(int n) {
	for(int i=1;i<n;i=i*2) {
		for(int j=0;j<n;j++) {
			System.out.println("test");
		}
	}
}

大O表示法

其中的log(n)+nlog(n)复杂度会省略低级的为nlog(n)。

打家劫舍（动态规划），三种方法进行实现

对树的深度递归的讲解。
https://blog.csdn.net/warmcore/article/details/78043771

一，运用递归的方法，在这里复杂度会是O（2^n）,占用的时间会很多。

public int rob3(int[] nums) {
		if(nums==null||nums.length==0)return 0;
		return rob3(nums,0);
	}
	private int rob3(int[] nums,int begin) {
		if(begin==nums.length-1)return nums[begin];
		if(begin==nums.length-2)return Math.max(nums[begin], nums[begin+1]);
		int robCur=nums[begin]+rob3(nums,begin+2);
		int robNext=rob3(nums,begin+1);
		return Math.max(robCur, robNext);
		
	}

这个看到在理解一下吧。

二，因为在上面调用递归的时候会有大量的重复调用，上面所用的方法和最上面的斐波那契的递归方法情况是一样的，所以可以用数组对数据进行缓存避免重复数据使用，在这里是多次的调用max这个函数进行的，这个可以认为是判断从后向前取最大值的 ，别看原来的时候是从i=0开始的，比如当跑到i=4的时候。这个时候就是判断是否去进行对此时的4进行偷，要进行偷的话就与此时在偷3时最大值进行比较，因为在原来的时候就已经判断了3时，所以这个就可以认为是从后往前偷，这里就比较容易了下面的代码和最后返回的值了。

	public int rob(int[] nums) {
	if(nums==null||nums.length==0)return 0;
	if(nums.length==1) return nums[0];
	int[] array=new int[nums.length];
	array[0]=nums[0];
	array[1]=Math.max(nums[0],nums[1]);
	for(int i=2;i<array.length;i++) {
		array[i]=Math.max(nums[i]+array[i-2], array[i-1]);
	}
	return array[array.length-1];
    }

三，这个用非递归方法直接运算的，所用的方法是和非递归运算斐波那契所用的方法一样，因为在这里面中我们在求的array[5]此时只需知道array[4]和array[3]就可以了。

public int rob1(int[] nums) {
		if(nums==null) return 0;
		if(nums.length==0)return 0;
		if(nums.length==1)return nums[0];
		int prev=nums[0];
		int cur=Math.max(nums[0], nums[1]);
		for(int i=2;i<nums.length;i++) {
			int tmp=cur;
			cur=Math.max(nums[i]+prev, cur);
			prev=tmp;
		}
		return cur;
	}

四，对第三步骤的简化。

public int rob2(int[] nums) {
		if(nums==null)return 0;
		int first=0,second=0;
		for(int i=0;i<nums.length;i++) {
			int tmp=second;
			second=Math.max(nums[i]+first, second);
			first=tmp;
		}
		return second;
	}