剑指offer第5-10题

仔细想了想，为了便于思考和整理，每个文档写5篇题目比较合适，这样既方便自己查看，计数也比较便利，所以这个就是将第6题到第十题的内容写入了，继续前进吧

旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
题目分析：这个题目看上去非常简单，因为只需要遍历，找到前一个数大于后一个数的时候，后面那个数就是最小值，时间复杂度N，空间复杂度1.
但是这并不是最简单最快的方法，利用二分法可以更快速的检索，时间复杂度只需要logN，空间复杂度1.

//递归写法
class Solution {
public:
	int twosearch(vector<int>rotateArray, int low, int high) {
		if (high == low)return rotateArray[low];
		if (high - low == 1)return rotateArray[low] < rotateArray[high] ? rotateArray[low] : rotateArray[high];
		int mid = (high + low) / 2;
		

		if (rotateArray[mid] >= rotateArray[low]) {
			return twosearch(rotateArray, mid, high);
		}
		if (rotateArray[mid] < rotateArray[low]) {
			return twosearch(rotateArray, low, mid);
		}
	}

	int minNumberInRotateArray(vector<int> rotateArray) {
		int arraynum = rotateArray.size();
		return twosearch(rotateArray, 0, arraynum - 1);
	}
};

//非递归写法
class Solution {
public:
	

	int minNumberInRotateArray(vector<int> rotateArray) {
		int arraynum = rotateArray.size();
		int i = 0; j = arraynum - 1;
		int minnum;
		while (1) {
			if (i == j) {
				minnum = rotateArray[i];
				break;
			}
			if (j - i == 1) {
				minnum= rotateArray[i] < rotateArray[j] ? rotateArray[i] : rotateArray[j];
				break;
			}
			int mid = (i + j) / 2;
			if (rotateArray[mid] >= rotateArray[i]) {
				i = mid;
			}
			if (rotateArray[mid] < rotateArray[i]) {
				j = mid;
			}
		}
		return minnum;
	}
};

斐波那契数列

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
题目分析：这道题属于最简单的递归入门题，但是考虑到牛客网上弱鸡的编译器能力，因此采用循环可能比较好，而且明显性能更优。

//递归写法，比较简单，而且很容易懂
class Solution {
public:
	int Fibonacci(int n) {
		if (n == 0)return 0;
		if (n == 1)return 1;
		return Fibonacci(n - 1) + Fibonacci(n - 2);
	}
};

//非递归写法，性能上会好一些
class Solution {
public:
	int Fibonacci(int n) {
		if (n == 0)return 0;
		if (n == 1)return 1;
        int output;
        int pre1=0;int pre2=1;   //pre1和pre2分别保存前两次的数据值
		for(int i=1;i<n;i++){   //这里的重点是确定循环的次数
            output=pre1+pre2;
            pre1=pre2;
            pre2=output;
        }
        return output;
	}
};

跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
题目分析：这个题本身其实就是递归分析。这里用递归的思想分析。1级台阶只有一种跳法，2级别台阶有2中跳法，三级台阶则有三种跳法。这里引用了别人的分析，我觉得比我的直觉要好的多。

对于本题,前提只有 一次 1阶或者2阶的跳法。

a.如果两种跳法，1阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1);

b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)

c.由a\b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)

d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1 ,只有两阶的时候可以有 f(2) = 2

e.可以发现最终得出的是一个斐波那契数列：

因此这道题就转化成了一道斐波那契数列的题，和上一题结果一致，因此我个人觉得就没有什么写的必要了，这里就不再重复写了。

变态跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
题目分析：这道题明显难度就大了很多，因为n是一个变量，所以就很难用传统的递归方法找到合适的解法。f(n) = f(n-1) + f(n-2) + f(n-3)+…+ f(2)+ f(1)。核心还是找到一个递归关系。
通过分析f(n-1) = f(n-2) + f(n-3) + f(n-4)+…+ f(2)+ f(1)，两个公式相减即可得到f(n) =2* f(n-1)，之后就豁然开朗了，具体写法如下图所示：

//递归写法
class Solution {
public:
    int jumpFloorII(int number) {
        if(number==0){return 0;}
        if(number==1){return 1;}
        return 2*jumpFloorII(number-1);
    }
};

//非递归写法，其实就是求2的n-1次方
class Solution {
public:
    int jumpFloorII(int number) {
        if(number==0)return 0;
        if(number==1)return 1;
        int pre=1;
        int output;
        for(int i=1;i<number;i++){
            output=2*pre;
            pre=output;
        }
        return output;
    }
};

矩形覆盖

题目描述：我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
题目分析：这个矩形比较特殊，最大宽度只有2，只能容纳一个小矩形竖排。这种题目前面的排布规律如果会影响后面的排布规律的话，一般都是通过递归分析的。仔细分析的话可以推导出具体的关系。
f(n) = f(n-1)+一个竖排 或者 f(n) = f(n-2)+两个横排，所以综合分析后：
f(n) = f(n-1) + f(n-2) ,具体解法如下：

class Solution {
public:
    int rectCover(int number) {
        if (number == 0) { return 0; }
        if (number == 1) { return 1; }
	    if (number == 2) { return 2; }
        int first=1,second=2,third;
	    for(int i=3;i<=number;i++)
        {
            third=first+second;
            first=second;
            second=third;
        }
        return third;
    }
};