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>


很简单,但我总觉得有点繁杂,

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


三、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呢?

通过矩阵行列式,可以推演出:

FizzBuzz and Fibonacci优化_第1张图片

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

如果直接计算,那么时间复杂度是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******************************************

你可能感兴趣的:(FizzBuzz,Fibonacci优化,5种优化)