[编程之美] PSet2.9 斐波那契数列



问题：

斐波那契数列由如下递推关系式定义：F(0) = 0，F(1)=1，F(n)=F(n-1)+F(n-2) if n>1。

常见的解法如下：

//递归解法解Fibonacci数列
int Fibonacci(int n)
{
	if(n<0){
		cerr<<"Fibonacci数列项数不能为负值\n"<<endl;
		return -1;
	}
	if(n==1 || n==0)
		return n;
	else
		return Fibonacci(n-1)+Fibonacci(n-2);
}

我们的问题是：我们有没有更加优化的解法呢？

解法一：递推关系式的优化

由于在递归求解的过程中重复计算了多次，比如F(5)=F(4)+F(3)；而在计算F(4)的时候又要重复的计算一次F(3)的大小···，因为每次计算都需要重复计算以前计算过的值，画出一棵递归树，每个节点都需要计算一遍。因此算法复杂度O(2^N)。

如果进行优化，可以使用一个数组存储Memo，对于计算过的不用重复计算，此时空间复杂度 O(N)，时间复杂度也为O(N)，如果使用自底向上的循环方法求解，也可以减少重复计算。代码如下：

//循环方式解Fibonacci数列
int Fibonacci(int n)
{
	int f0=0,f1=1,result=-1;
	if(n<0){
		cerr<<"Fibonacci数列项数不能为负\n"<<endl;
		exit(-1);
	}
	if(n == 0)
		return f0;
	else if(n==1)
		return f1;
	for(int i=2 ; i<=n ; i++){
		result = f0+f1;
		f0=f1;
		f1=result;
	}
	return result;
}

这种方式需要O(N)级别的时间复杂度，挺不错的，只是需要对这个数列有非常清晰的把握。

解法二：求解通项公式

由递推公式F(n) = F(n-1)+F(n-2)知道f(n)的特征方程为 x*x = x + 1，根为s1=(1+sqrt(5))/2 和s2=(1-sqrt(5))/2。那么存在A，B使得：f(n)=A*s1^n + B*s2^n，代人f(0)=0,f(1)=1，得到A=sqrt(5)/5，B=-sqrt(5)/5。即f(n)=A*s1 + B*s2。因此只需要运算一次就能在常数时间O(1)内得到结果，但是公式中引入了无理数，不能保证结果的精度。

解法三：分治策略

注意到斐波那契数列是二阶递推数列，所以存在一个2*2的矩阵A，使得：
(Fn, Fn-1) = (Fn-1, Fn-2)*A
求得A=(1 1)
            (1 0)

于是(Fn,Fn-1) = (F1 , F0) * A^(n-1)
那么求数列的第n项就是等于求矩阵A的第n-1次幂。因为计算A的n-1乘法有快速相乘的方法，比如计算m的10000次方，其实最少的计算次数，等于10000的最高比特位的位置与零的个数，即14次左右乘法运算（计算2^i<10000的i的最大值），并不需要10000次傻乘。

快速相乘的方法：

想要求A^n，那么由n的二进制表示为：

可以很容易的通过logn次乘法得到A^n，举例子：A^5=(A^2)^2 * A

代码如下：

//定义整数 Martix类
class Matrix{
private:
	int row,col;
	int **dat;
public:
	//Matrix();//不允许默认构造函数
	Matrix(int r, int c);
	/*在C++中，下面三种对象需要拷贝的情况。因此，拷贝构造函数将会被调用。
		1)． 一个对象以值传递的方式传入函数体
		2)． 一个对象以值传递的方式从函数返回
		3)． 一个对象需要通过另外一个对象进行初始化*/
	Matrix(const Matrix&mat);

	~Matrix();
	int Row(){return this->row;}
	int Col(){return this->col;}
	Matrix MatrixMult(const Matrix &mat)const;
	Martix& operator= (const Matrix &mat);
	int* operator[] (int row){return this->dat[row];}//返回第row行的行指针
	const int*operator[](int row)const{return this->dat[row];}// 返回第row行的常量指针，指向常量的指针
	

	friend istream& operator>> (istream& in , Matrix& mat);
	friend ostream& operator<< (ostream& out , Matrix& mat);
};
//拷贝构造函数，此处有dat指针，应避免浅拷贝
Matrix::Matrix(const Matrix&mat)
{
	this->row = mat.row;
	this->col = mat.col;
	
	//复制数据块
	dat = new int* [row];//指针数组
	for(int i=0 ; i<row ; i++){
		dat[i] = new int[col];
		memset(dat[i] , 0 , sizeof(int)*col);
	}
	for(int i=0 ; i<mat.row ; i++)
		for(int j=0 ; j<mat.col ; j++)
			this->dat[i][j] = mat.dat[i][j];
}
Matrix::Matrix(int r, int c)
{ 
	this->row = r;
	this->col = c;
	dat = new int* [row];//指针数组
	for(int i=0 ; i<row ; i++){
		dat[i] = new int[col];
		memset(dat[i] , 0 , sizeof(int)*col);
	}
}
Matrix::~Matrix()
{
	//先释放该指针数组每个元素指向的数组，再释放该指针数组
	for(int i=0 ; i<row ; i++){
		delete [col]dat[i];
		dat[i] = NULL;
	}
	delete [row]dat;
	dat = NULL;
}
Martix& Matrix::operator= (const Matrix &mat)
{	if(this == &mat) return *this;
	this->col = mat.col;
	this->row = mat.row;
	for(int i=0 ; i<row ; i++)
		for(int j=0 ; j<col ; j++)
			(*this)[i][j] = mat[i][j];return *this;//返回本身的引用
}
istream& operator>> (istream& in , Matrix& mat)
{
	for(int i=0 ; i<mat.row ; i++)
		for(int j=0 ; j<mat.col ; j++)
			in>>mat.dat[i][j];
	return in;
}

ostream& operator<< (ostream& out , Matrix& mat)
{
	for(int i=0 ; i<mat.row ; i++){
		for(int j=0 ; j<mat.col ; j++){
			out<<mat.dat[i][j]<<" ";
			if(j == mat.col-1)//换行
				out<<endl;
		}
	}
	return out;
}
Matrix Matrix::MatrixMult(const Matrix &mat)const
{
	assert(this->col == mat.row);
	int tempRow = this->row;
	int tempCol = mat.col;
	Matrix temp(tempRow , tempCol);
	for(int i=0 ; i<tempRow ; i++){
		for(int j=0 ; j<tempCol ; j++){
			for(int k=0 ; k<this->col ; k++)//k遍历所有待乘的数
				temp[i][j] += (*this)[i][k]*mat[k][j];
		}
	}
	return temp;//调用拷贝构造函数
}
int Fibonacci(int N)
{
	Matrix res(2,2);
	if (N==0) return 0;  
	--N;    // 计算矩阵prod的n-1次幂  
	res[0][0] = 1; res[0][1] = 0;   
	res[1][0] = 0; res[1][1] = 1;  
	Matrix prod(2,2); 
	prod[0][0] = 1;  prod[0][1] = 1;  
	prod[1][0] = 1;  prod[1][1] = 0;  
	// 只需要O(logn)的复杂度就能算出x的n次幂    
	while(N)
	{
		if(N&1)
			res = res.MatrixMult(prod);
		prod = prod.MatrixMult(prod);
		N=N>>1;
	}
	return res[0][0];  
}

int main()
{

	cout<<Fibonacci(20)<<endl;
	return 0;
}

注意：本人突然意识到本代码中Martix类重载的赋值运算符有问题！会产生内存泄露，正确的应该在复制mat数据到*this之前应该清空*this的指针dat指向的指针数组以及该指针数组指向的数组元素。否则将会没机会释放这部分内存，造成内存泄露！