斐波那契数列算法分析.docx
《斐波那契数列算法分析.docx》由会员分享，可在线阅读，更多相关《斐波那契数列算法分析.docx（10页珍藏版）》请在冰豆网上搜索。
斐波那契数列算法分析
斐波那契数列算法分析
斐波那契数列算法分析
背景：
假定你有一雄一雌一对刚出生的兔子，它们在长到一个月大小时开始交配，在第二月结束时，雌兔子产下另一对兔子，过了一个月后它们也开始繁殖，如此这般持续下去。
每只雌兔在开始繁殖时每月都产下一对兔子，假定没有兔子死亡，在一年后总共会有多少对兔子？
在一月底，最初的一对兔子交配，但是还只有1对兔子；在二月底，雌兔产下一对兔子，共有2对兔子；在三月底，最老的雌兔产下第二对兔子，共有3对兔子；在四月底，最老的雌兔产下第三对兔子，两个月前生的雌兔产下一对兔子，共有5对兔子；……如此这般计算下去，兔子对数分别是：
1,1,2,3,5,8,13,21,34,55,89,144,...看出规律了吗？
从第3个数目开始，每个数目都是前面两个数目之和。
这就是著名的斐波那契（Fibonacci）数列。
有趣问题：
1，有一段楼梯有10级台阶,规定每一步只能跨一级或两级,要登上第10级台阶有几种不同的走法?
答：
这就是一个斐波那契数列：
登上第一级台阶有一种登法；登上两级台阶，有两种登法；登上三级台阶，有三种登法；登上四级台阶，有五种方法……所以，1，2，3，5，8，13……登上十级，有89种。
2，数列中相邻两项的前项比后项的极限是多少，就是问，当n趋于无穷大时，F（n）/F（n+1）的极限是多少？
答：
这个可由它的通项公式直接得到，极限是（-1+√5）/2，这个就是所谓的黄金分割点，也是代表大自然的和谐的一个数字。
数学表示：
Fibonacci数列的数学表达式就是：
F（n）=F（n-1）+F（n-2）
F
（1）=1
F
（2）=1
递归程序1：
Fibonacci数列可以用很直观的二叉递归程序来写，用C++语言的描述如下：
longfib1（intn）
{
if（n<=2）
{
return1;
}
else
{
returnfib1（n-1）+fib1（n-2）;
}
}
看上去程序的递归使用很恰当，可是在用VC2005的环境下测试n=37的时候用了大约3s，而n=45的时候基本下楼打完饭也看不到结果……显然这种递归的效率太低了！
！
递归效率分析：
例如，用下面一个测试函数：
longfib1（intn,int*arr）
{
arr[n]++;
if（n<=2）
{
return1;
}
else
{
returnfib1（n-1,arr）+fib1（n-2,arr）;
}
}
这时，可以得到每个fib（i）被计算的次数：
fib（10）=1fib（9）=1fib（8）=2fib（7）=3
fib（6）=5fib（5）=8fib（4）=13fib（3）=21
fib
（2）=34fib
（1）=55fib（0）=34
可见，计算次数呈反向的Fibonacci数列，这显然造成了大量重复计算。
我们令T（N）为函数fib（n）的运行时间，当N>=2的时候我们分析可知：
T（N）=T（N-1）+T（N-2）+2
而fib（n）=fib（n-1）+fib（n-2），所以有T（N）>=fib（n），归纳法证明可得：
fib（N）<（5/3）^N
当N>4时，fib（N）>=（3/2）^N
标准写法：
显然这个O（（3/2）^N）是以指数增长的算法，基本上是最坏的情况。
其实，这违反了递归的一个规则：
合成效益法则。
合成效益法则（Compoundinterestrule）：
在求解一个问题的同一实例的时候，切勿在不同的递归调用中做重复性的工作。
所以在上面的代码中调用fib（N-1）的时候实际上同时计算了fib（N-2）。
这种小的重复计算在递归过程中就会产生巨大的运行时间。
递归程序2：
用一叉递归程序就可以得到近似线性的效率，用C++语言的描述如下：
longfib（intn,longa,longb,intcount）
{
if（count==n）
returnb;
returnfib（n,b,a+b,++count）;
}
longfib2（intn）
{
returnfib（n,0,1,1）;
}
这种方法虽然是递归了，但是并不直观，而且效率上相比下面的迭代循环并没有优势。
迭代解法：
Fibonacci数列用迭代程序来写也很容易，用C++语言的描述如下：
//也可以用数组将每次计算的f（n）存储下来，用来下次计算用（空间换时间）
longfib3（intn）
{
longx=0,y=1;
for（intj=1;j{
y=x+y;
x=y-x;
}
returny;
}
这时程序的效率显然为O（N），N=45的时候<1s就能得到结果。
矩阵乘法：
我们将数列写成：
Fibonacci[0]=0，Fibonacci[1]=1
Fibonacci[n]=Fibonacci[n-1]+Fibonacci[n-2]（n>=2）
可以将它写成矩阵乘法形式：
将右边连续的展开就得到：
下面就是要用O（log（n））的算法计算：
显然用二分法来求，结合一些面向对象的概念，C++代码如下：
classMatrix
{
public:
longmatr[2][2];
Matrix（constMatrix&rhs）;
Matrix（longa,longb,longc,longd）;
Matrix&operator=（constMatrix&）;
friendMatrixoperator*（constMatrix&lhs,constMatrix&rhs）
{
Matrixret（0,0,0,0）;
ret.matr[0][0]=lhs.matr[0][0]*rhs.matr[0][0]+lhs.matr[0][1]*rhs.matr[1][0];
ret.matr[0][1]=lhs.matr[0][0]*rhs.matr[0][1]+lhs.matr[0][1]*rhs.matr[1][1];
ret.matr[1][0]=lhs.matr[1][0]*rhs.matr[0][0]+lhs.matr[1][1]*rhs.matr[1][0];
ret.matr[1][1]=lhs.matr[1][0]*rhs.matr[0][1]+lhs.matr[1][1]*rhs.matr[1][1];
returnret;
}
};
Matrix:
:
Matrix（longa,longb,longc,longd）
{
this->matr[0][0]=a;
this->matr[0][1]=b;
this->matr[1][0]=c;
this->matr[1][1]=d;
}
Matrix:
:
Matrix（constMatrix&rhs）
{
this->matr[0][0]=rhs.matr[0][0];
this->matr[0][1]=rhs.matr[0][1];
this->matr[1][0]=rhs.matr[1][0];
this->matr[1][1]=rhs.matr[1][1];
}
Matrix&Matrix:
:
operator=（constMatrix&rhs）
{
this->matr[0][0]=rhs.matr[0][0];
this->matr[0][1]=rhs.matr[0][1];
this->matr[1][0]=rhs.matr[1][0];
this->matr[1][1]=rhs.matr[1][1];
return*this;
}
Matrixpower（constMatrix&m,intn）
{
if（n==1）
returnm;
if（n%2==0）
returnpower（m*m,n/2）;
else
returnpower（m*m,n/2）*m;
}
longfib4（intn）
{
Matrixmatrix0（1,1,1,0）;
matrix0=power（matrix0,n-1）;
returnmatrix0.matr[0][0];
}
这时程序的效率为O（log（N））。
公式解法：
在O
（1）的时间就能求得到F（n）了：
注意：
其中[x]表示取距离x最近的整数。
用C++写的代码如下：
longfib5（intn）
{
doublez=sqrt（5.0）;
doublex=（1+z）/2;
doubley=（1-z）/2;
return（pow（x,n）-pow（y,n））/z+0.5;
}
这个与数学库实现开方和乘方本身效率有关的，我想应该还是在O（log（n））的效率。
总结：
上面给出了5中求解斐波那契数列的方法，用测试程序主函数如下：
intmain（）
{
cout<cout<cout<cout<cout<return0;
}
函数fib1会等待好久，其它的都能很快得出结果，并且相同为：
1134903170。
而后面两种只有在n=1000000000的时候会显示出优势。
由于我的程序都没有涉及到高精度，所以要是求大数据的话，可以通过取模来获得结果的后4位来测试效率与正确性。
另外斐波那契数列在实际工作中应该用的很少，尤其是当数据n很大的时候（例如：
1000000000），所以综合考虑基本普通的非递归O（n）方法就很好了，没有必要用矩阵乘法。
1、N皇后问题算法设计
ALGORITHM
procedurePLACE（k）
//如果一个皇后能放在第k行的X（k）列，则返
回true；否则返回false。
X是一个全程数
组，进入此过程时已置了k个值。
//
globalX（1：
k）；integeri，k
i←1
whileiifX（i）＝X（k）//在同一列有两个皇后//
orABS（X（i）－X（k））＝ABS（i－k）
//在同——条斜角线上//
thenreturn（false）
endif
i←i+1
repeat
return（true）//满足约束//
endPLACE
procedureNQUEENS（n）
//此过程使用回溯法求出在一个n*n棋盘上放置n个皇后，使其能互相攻击的所有可能位置//
X
（1）←0；k←1//k是当前行；X（k）是当前列//
Whilek>0do//对所有的
升级会员 