FizzBuzz and Fibonacci优化

***************************************转载请注明出处：http://blog.csdn.net/lttree******************************************

一、引言

今天早上，例行随便看看。

看到里面这段：

招聘程序设计人员，尤其是提到代码，最流行的将鱼目混珠的程序猿剔除的问题是 “Fizz-Buzz” 測试。

假设一个程序猿无法在10-15分钟之间写出一个 Fizz-buzz，那他可能须要很多其它的锻炼。也许根本没有准备好。另外一个方法就是让他们写 Fibonacci series(斐波纳契数列)，并请他们优化一下。大家都知道 Fibonacci 是非经常见的，可是你可能会非常吃惊的看到这些程序猿非常难在之上写出这些数列，即使是在 IDE 上也写不出来。

恩，话说不懂什么事Fizz-buzz測试。。

。

于是Wiki了一下 -> http://en.wikipedia.org/wiki/Fizz_buzz

好吧，就是个报数游戏，3或3的倍数喊Fizz。5或5的倍数喊Buzz，假设既是3又是5的倍数喊FizzBuzz。

重点是后面的那个Fibonacci 的优化。

我仅仅知道递归和递推两种，上网搜了搜，果真优化非常多

看到了时间复杂度O（log(n)）空间复杂度O（1）的方法。

就想学习一下

二、Fizz-Buzz

这个我认为没有难度，

这是我写的：

<span style="font-family:Comic Sans MS;font-size:14px;">// Fizz Buzz  
void FizzBuzz( int n )
{
    bool isFZ;
    for( int i = 1 ; i <= n ; ++i )
    {
        isFZ=false;
        if( i % 3 == 0 )    {cout<<"Fizz";isFZ=true;}
        if( i % 5 == 0 )    {cout<<"Buzz";isFZ=true;}
        if( !isFZ ) cout<<i;
        cout<<" ";
        if( i % 10 == 0 )   cout<<endl;
    }
}</span>

非常easy。但我总认为有点繁杂。

希望会更好的方法的。留下代码，学习一下~

三、Fibonacci的优化

简单说一下Fibonacci 数列

有一种理想型生物，都拿兔子来说= =。

刚開始有这么一对兔子。每月初能够生一对兔子。而刚出生的兔子到第三个月初開始，也能够生每月初生一对兔子。

这样下去，到第n个月，会有多少对兔子？

来一个表格：

月份： 012 3 4 56... n

①兔： 001 1 2 35... n-1_成年兔+n-1_②兔

推导: n-1_成年兔 = n-2_成年兔+n-2_②兔，n-1_②兔=n-2_①兔

n-1_成年兔+n-1_②兔= n-2_兔总

②兔： 000 1 1 23... n-1_①兔

成年兔： 011 1 2 35... n-1_成年兔+n-1_②兔

兔总： 012 3 5 813... n-1_兔总+n-2兔总

PS：①兔表示一个月大的兔子。②兔即两个月大兔子。里面的数字是兔子的对数。

这是推倒出来

第n个月的 ①兔对数等于该月成年兔对数

第n个月的 ②兔对数等于第 n-1月的①兔对数

第n个月的成年兔对数等于第n-1月的成年兔对数+②兔对数

然后再依据n-1 推 n-2 的发现

第n个月兔子对数等于第n-1月与第n-2月兔子对数之和。

这是按我的理解思路，讲述的。。

有点绕。不知道懂了木有。。。

主要的Fibonacci概念说完了，如今看它们的解法：

1.最简单暴力好读的——递归方法

时间复杂度：O（2^n）

空间复杂度：数字过大可能导致栈溢出

<span style="font-family:Comic Sans MS;font-size:14px;">int digui( int n )
{
    if( n == 0 )
        return 0;
    else if( n == 1 )
        return 1;
    else
        return ( digui(n-1) + digui(n-2) );
}</span>

2.省空间也省了时间的，递归进阶——递推方法

时间复杂度：O（n）

空间复杂度：O（n）

<span style="font-family:Comic Sans MS;font-size:14px;">// 普通递推算法
int* ditui( int n )
{
    int* arr = new int[n+1];
    arr[0]=0,arr[1]=1;

    for( int i = 2 ; i <= n ; ++i )
        arr[i]=arr[i-1]+arr[i-2];

    return arr;
}</span>

3.继续优化——优化递推法

我们能够看到，假设求第n个Fibonacci数，

我们仅仅须要知道第n-1和第n-2个的Fibonacci数就可以。

前面的不须要存储。

所以。就有了更优化。

时间复杂度：O（n）

空间复杂度：O（1）

<span style="font-family:Comic Sans MS;font-size:14px;">// 递推算法优化
int ditui_opt( int n )
{
    if( n < 2 ) return n;
    int i = 1,pre1=0,pre2=1;
    while( i < n )
    {
        pre2 = pre2 + pre1;
        pre1 = pre2 - pre1;
        ++i;
    }
    return pre2;
}</span>

4.更优化的——矩阵法

时间复杂度：O（log(n) ）

空间复杂度：数字过大可能导致栈溢出

递归、递推已经无法优化时间复杂度了，

空间都到了O（1）了。也没法再精进了，

so，有没有别的方法来进行进一步优化呢？

Of course！

我们能够发现。事实上f(n) 都是 f(0)和f(1) 有关的：

f(2) = f(1) + f(0);

f(3) = f(2) + f(1) = 2*f(1) + f(0);

f(4) = f(3) + f(2) = 3*f(1) + 2*f(0);

.......

所以未来的f(n)一定等于：

f(n) = a*f(1) + b*f(0);

但是，怎样求a和b呢?

通过矩阵行列式，能够推演出：

这样。关键就是求矩阵的次方了，

假设直接计算。那么时间复杂度是O（n），根本就没有什么优化。

所以，此时，我们就要用二分法（分治法）来解决

M^a = M^(a/2) * M^(a/2) = ....

这样，时间复杂度能够优化到O（log(n) ）！

<span style="font-family:Comic Sans MS;font-size:14px;">// 矩阵优化 方法

// 构造个矩阵结构体
struct Matrix
{
    int m0,m1,m2,m3;
};
// 矩阵乘法
Matrix mat_mul( Matrix mtx1 , Matrix mtx2 )
{
    Matrix mat;
    mat.m0 = mtx1.m0 * mtx2.m0 + mtx1.m1 * mtx2.m2;
    mat.m1 = mtx1.m0 * mtx2.m1 + mtx1.m1 * mtx2.m3;
    mat.m2 = mtx1.m2 * mtx2.m0 + mtx1.m3 * mtx2.m2;
    mat.m3 = mtx1.m2 * mtx2.m1 + mtx1.m3 * mtx2.m3;
    return mat;
}
// 矩阵乘方
Matrix mat_pow( int k )
{
    Matrix mat;
    if( k == 1 )
    {
        mat.m0=1;
        mat.m1=1;
        mat.m2=1;
        mat.m3=0;
    }
    else if( k % 2 == 0)
    {
        mat = mat_pow( k/2 );
        mat = mat_mul( mat , mat );
    }
    else
    {
        mat = mat_pow( (k - 1) / 2 );
        mat = mat_mul( mat , mat );
        mat = mat_mul( mat , mat_pow(1) );
    }
    return mat;
}
// 最后求Fibonacci
int fib_matrix( int n )
{
    if( n < 2 )    return n;

    Matrix mat;
    mat = mat_pow(n-1);

    int ans;
    ans = mat.m0 + mat.m1;
    return ans;
}</span>

这样的方法时间上压缩到了log(n),但是空间上，由于二分法，算是递归的过程，

有可能会导致栈溢出。

于是乎，又有了优化方法。

5.优化中的优化

时间复杂度：O（log(n)）

空间复杂度：O（1）

没错。就是O（1）。

压缩空间复杂度。并且是对于递归，

并且。这是对于矩阵法的优化，

难度，肯定在于

1 1

1 0

矩阵的n-1次方的求法，

将这个用递推实现，

我们会发现：

f(1)——为简化。f（1）表示 n=1时矩阵的n-1次方。用mat代表矩阵

f（1） = 1。

f（2） = mat

f（3） = f（2）* f（1）

f（4） = f（3）* f（1） = f（2） * f（2）

f（5） = f（4）* f（1）

f（6） = f（5）* f（1） = f（3） * f（3）

......

看到规律了吗？

就是说，当f（n）中

n为偶数，

f（n）= f（n/2） * f（n/2）

n为奇数

f（n）= f（n-1）* f（1）

因此。我们不须要将所有的数所有存储就可以计算了。

算法之路。博大精深啊。

。

***************************************转载请注明出处：http://blog.csdn.net/lttree******************************************