面试题整理-斐波那契数列

最新推荐文章于 2021-12-23 17:00:00 发布
最新推荐文章于 2021-12-23 17:00:00 发布
阅读量1.6k 收藏
点赞数 1
分类专栏： 算法与数据结构 C++知识总结 文章标签： 算法与数据结构 C++ 面试题

这个很好。其实也就是f(0) = 0, f(1) = 1. 然后 f(n) = f(n-1) +  f(n-2);

测试链接点击打开链接。求解：

#include <stdio.h>  
#include <stdlib.h>  
  
long long a[71];  
void init(void) {  
    a[0] = 0;  
    a[1] = a[2] = 1;  
    for (int i = 3; i < 71; ++i) {  
        a[i] = a[i-1] + a[i-2];  
    }  
}  
  
int main(void) {  
    int n;init();  
    while (scanf("%d", &n) != EOF) {  
        printf("%lld\n", a[n]);  
    }  
    return 0;  
}  
//注意打表及长整型。

解题

首先，不要用递归的方法。那个是很烂的解法。直接忽略。这里也不用打表的方法。也就是说，每给一个数。直接进行计算从而得到结果。

你可能会想到下面的这个方法：

int fib(int n) {  
    if (0 == n) return 0;  
    if (1 == n || 2 == n) return 1;  
    int a = 1, b = 1, ret = 0;  
    for (int i = 3; i <= n; ++i) {  
        ret = a + b;  
        b = a;  
        a = ret;  
    }  
    return ret;  
}

但是这种方法，有个很明显的缺点。也就是容易溢出。32位只能计算至45。64位只能计算至92。所以当数值一大，不管是用long或者long long也好。都不能解决。

 

大整数斐波那契数列-推荐使用，简单有效

那么首先想到的是利用大整数来进行求解。这里我们用string来摸拟大整数。

#include <iostream>  
#include <string>  
#include <stdio.h>  
#include <stdlib.h>  
using namespace std;  
  
string &_string_add_string(const string &a, const string &b, string &res)  
{  
    int sum_value = 0, add_bit = 0;  
    const int alen = a.length(), blen = b.length();  
    res = "0" + (alen > blen ? a : b);  
    for (int i = alen-1, j = blen-1, k = res.length() - 1;   
         i >= 0 || j >= 0 || add_bit > 0;   
         --i, --j, --k){  
        sum_value = (i>=0 ? a[i]-48: 0) + (j>=0 ? b[j]-48: 0) + add_bit;  
        add_bit = sum_value / 10;   
        res[k] = sum_value%10 + '0';  
    }  
    if (res[0] == '0') res = res.substr(1, res.length() - 1);  
    return res;  
}  
  
string fib(int n) {  
    if (0 == n) return "0";  
    if (1 == n || 2 == n) return "1";  
    string a = "1", b = "1", ret = "0";  
    for (int i = 3; i <= n; ++i) {  
        _string_add_string(a, b, ret);  
        b = a;  
        a = ret;  
    }  
    return ret;  
}  
  
int main(void)  
{  
    int n;  
    string a, b, c;  
    string ret;  
    while (scanf("%d", &n) != EOF) {  
        printf("%s\n", fib(n).c_str());  
    }  
    return 0;  
}

现在得到一个大整数的解法。也就是对于任意大的数。都可以得到解。现在希望对这个进行改进。大数的加法，测试地址。

lg(n)的斐波那契数列

首先是效率问题，当n特别大的时候。求解起来，很不方便。于是我们想怎么去改进这个效率。

比如F(n) = F(n - 1) + F(n-2);

从而可以得到矩阵公式：

[F(n) F(n-1)] = [F(n-1) F(n-2)] * A;

A矩阵等于

1 1

1 0

不用多说，把公式展开。也就是[ F(n) F(n-1)] = [F(1) F(0)] * pow(A, n-1);

而我们知道[ F(1) F(0)] = [ 1 0]; 也就是说F(n) = pow(A, n - 1) [0][0];

也就是矩阵pow(A, n-1) 最左上角的第一个元素。

实际，也就是把O(n)的累加问题变成了pow()指数问题。

这里写一个高效的pow()模板。是O(log2n)。

template<typename T>  
T pow(T a, int n)  
{  
    T odd = 1;  
    while (n)  
    {  
        if (n&1) odd *= a;  
        a *= a;  
        n>>=1;  
    }  
    return odd;  
}
根据这个模板，我们只需要重写一个矩阵的乘法就可以了。不要去写一个矩阵类啊。 

#include <stdio.h>  
#include <stdlib.h>  
  
typedef struct _node  
{  
    long long a, b;  
    long long c, d;  
} node;  
  
  
void _multiple(node *x, node *y) {  
    node temp;  
    temp.a = x->a*y->a + x->b*y->c;  
    temp.b = x->a*y->b + x->b*y->d;  
    temp.c = x->c*y->a + x->d*y->c;  
    temp.d = x->c*y->b + x->d*y->d;  
    *x = temp;  
}  
  
long long fib(int n)  
{  
    if (0 == n) return 0;  
    if (1 == n || 2 == n) return 1;  
  
    node odd; odd.a = odd.d = 1; odd.c = odd.b = 0; //单位矩阵  
    node temp; temp.a = temp.b = temp.c = 1; temp.d = 0; // A矩阵  
  
    --n;  
    while (n) {  
        if (n&1) _multiple(&odd, &temp);  
        _multiple(&temp, &temp);  
        n >>= 1;  
    }  
  
    return odd.a;  
}  
  
int main()  
{  
    int n;  
    while (scanf("%d", &n) != EOF) {  
        printf("%lld\n", fib(n));  
    }  
    return 0;  
}

结构很清晰。但是还是有前面提出来的问题。也就是溢出问题。C++没有大数。算了，还是自己用string模拟一下吧。

大数的乘法

我们只需要处理的是大数的乘法。而大数的乘法是依赖于大数的加法的。所以相当于加法与乘法都要用到。

那么先来个大数的乘法吧。大数乘法。

#include <iostream>  
#include <string>  
using namespace std;  
  
string &_del_zeros_before_dot(string &a)  
{  
    if (a.length() <= 0 || a[0] != '0') return a;  
    int i = 0;  
    while (i < a.length() && a[i] == '0') ++i;  
    a = a.substr(i, a.length() - i);  
    return a;  
}  
  
string &_string_add_string(const string &a, const string &b, string &res)  
{  
    int sum_value = 0, add_bit = 0;  
    const int alen = a.length(), blen = b.length();  
    res = "0" + (alen > blen ? a : b);  
    for (int i = alen-1, j = blen-1, k = res.length() - 1;   
         i >= 0 || j >= 0 || add_bit > 0;   
         --i, --j, --k){  
        sum_value = (i>=0 ? a[i]-48: 0) + (j>=0 ? b[j]-48: 0) + add_bit;  
        add_bit = sum_value / 10;   
        res[k] = sum_value%10 + '0';  
    }  
    if (res[0] == '0') res = res.substr(1, res.length() - 1);  
    return res;  
}  
  
  
string &_gen_zeros_string(int n, string &res) {  
    string temp = "0";  
    res = "";  
    while (n) {  
        if (n&1) res += temp;  
        temp += temp;  
        n >>= 1;  
    }  
    return res;  
}  
  
string &_string_multiply_char(  
    const string &a,   
    char c, int n_zeros, string &res) {  
  
    int ch = c - '0';  
    string zeros_string;  
    _gen_zeros_string(n_zeros, zeros_string);  
    res = "0" + a + zeros_string;  
      
    const int alen = a.length();  
    for (int i = alen - 1, k = alen, add_bit = 0;   
        i >= 0 || add_bit > 0; --i, --k) {  
        int v = (i>=0 ? a[i]-48: 0) * ch + add_bit;  
        add_bit = v / 10;  
        res[k] = v % 10 + '0';  
    }  
    if (res[0] == '0') res = res.substr(1, res.length() - 1);  
  
    return res;  
}  
  
string &_string_multiply_string(const string &a, const string &b, string &res) {  
    string c = a, d = b;  
    _del_zeros_before_dot(c);  
    _del_zeros_before_dot(d);  
    int clen = c.length(), dlen = d.length();  
  
    if (clen < dlen) {   
        string t = c; c = d; d = t;  
        int x = clen; clen = dlen; dlen = x;  
    }  
  
    res = "0";  
    for (int i = dlen - 1; i >= 0; --i) {  
        string temp_res;  
        _string_multiply_char(c, d[i], (dlen - 1 - i), temp_res);  
  
        string add_res;  
        _string_add_string(res, temp_res, add_res);  
        res = add_res;  
    }  
    return res;  
}  
  
int main(void)  
{  
    string a, b, c;  
    while (cin >> a >> b) {  
        _string_multiply_string(a, b, c);  
        cout << c << endl;  
    }  
    return 0;  
}

大数乘法搞定之后，应该把大数引入至O(lgN)中去。

 带大数的斐波那契数--做研究，不是很推荐

 这里把大数模板代入到O(lgN)中去。

#include <iostream>  
#include <string>  
#include <stdio.h>  
#include <stdlib.h>  
using namespace std;  
  
string &_del_zeros_before_dot(string &a)  
{  
    if (a.length() <= 0 || a[0] != '0') return a;  
    int i = 0;  
    while (i < a.length() && a[i] == '0') ++i;  
    a = a.substr(i, a.length() - i);  
    return a;  
}  
  
string &_string_add_string(const string &a, const string &b, string &res)  
{  
    int sum_value = 0, add_bit = 0;  
    const int alen = a.length(), blen = b.length();  
    res = "0" + (alen > blen ? a : b);  
    for (int i = alen-1, j = blen-1, k = res.length() - 1;   
         i >= 0 || j >= 0 || add_bit > 0;   
         --i, --j, --k){  
        sum_value = (i>=0 ? a[i]-48: 0) + (j>=0 ? b[j]-48: 0) + add_bit;  
        add_bit = sum_value / 10;   
        res[k] = sum_value%10 + '0';  
    }  
    if (res[0] == '0') res = res.substr(1, res.length() - 1);  
    return res;  
}  
  
string &_gen_zeros_string(int n, string &res) {  
    string temp = "0";  
    res = "";  
    while (n) {  
        if (n&1) res += temp;  
        temp += temp;  
        n >>= 1;  
    }  
    return res;  
}  
  
string &_string_multiply_char(  
    const string &a,   
    char c, int n_zeros, string &res) {  
  
    int ch = c - '0';  
    string zeros_string;  
    _gen_zeros_string(n_zeros, zeros_string);  
    res = "0" + a + zeros_string;  
      
    const int alen = a.length();  
    for (int i = alen - 1, k = alen, add_bit = 0;   
        i >= 0 || add_bit > 0; --i, --k) {  
        int v = (i>=0 ? a[i]-48: 0) * ch + add_bit;  
        add_bit = v / 10;  
        res[k] = v % 10 + '0';  
    }  
    if (res[0] == '0') res = res.substr(1, res.length() - 1);  
  
    return res;  
}  
  
string &_string_multiply_string(const string &a, const string &b, string &res) {  
    string c = a, d = b;  
    _del_zeros_before_dot(c);  
    _del_zeros_before_dot(d);  
    int clen = c.length(), dlen = d.length();  
  
    if (clen < dlen) {   
        string t = c; c = d; d = t;  
        int x = clen; clen = dlen; dlen = x;  
    }  
  
    res = "0";  
    for (int i = dlen - 1; i >= 0; --i) {  
        string temp_res;  
        _string_multiply_char(c, d[i], (dlen - 1 - i), temp_res);  
  
        string add_res;  
        _string_add_string(res, temp_res, add_res);  
        res = add_res;  
    }  
    return res;  
}  
  
typedef struct _node {  
    string a, b;  
    string c, d;  
}node;  
  
inline void _m_fun(const string &a, const string &b,   
    const string &c, const string &d, string &res) {  
    string ares, bres;  
    _string_multiply_string(a, b, ares);  
    _string_multiply_string(c, d, bres);  
    _string_add_string(ares, bres, res);  
}  
void _multiple(node &x, node &y) {  
    node temp;  
    string ares, bres;  
    _m_fun(x.a, y.a, x.b, y.c, temp.a); //temp.a = x->a*y->a + x->b*y.c;  
    _m_fun(x.a, y.b, x.b, y.d, temp.b); //temp.b = x->a*y->b + x->b*y.d;  
    _m_fun(x.c, y.a, x.d, y.c, temp.c); //temp.c = x->c*y->a + x->d*y.c;  
    _m_fun(x.c, y.b, x.d, y.d, temp.d); //temp.d = x->c*y->b + x->d*y->d;  
    x = temp;  
}  
  
string fib(int n)  
{  
    if (0 == n) return "0";  
    if (1 == n || 2 == n) return "1";  
  
    node odd; odd.a = odd.d = "1"; odd.c = odd.b = "0"; //单位矩阵  
    node temp; temp.a = temp.b = temp.c = "1"; temp.d = "0"; // A矩阵  
  
    --n;  
    while (n) {  
        if (n&1) _multiple(odd, temp);  
        _multiple(temp, temp);  
        n >>= 1;  
    }  
  
    return odd.a;  
}  
  
int main(void)  
{  
    int n;  
    while (scanf("%d", &n) != EOF) {  
        string res = fib(n);  
        printf("%s\n", res.c_str());  
    }  
    return 0;  
}
不过虽然是引进了乘法，不过由于大数模板乘法效率并不高效。速度还是比较慢的。还是推荐前面利用加法的大数模板。
木顶思上
关注
专栏目录
面试之 斐波那契数列
前端小愤青
07-02 347
科普 斐波那契数列是以下一系列数字： 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,… 在种子0和1之后，后续的每一个数字都是前面两个数字之和。 实现 正常递归版本(*) function fibonacci(n){ if(n==0||n==1){ return n; } return fibonacci(n-1)+fibonacci(...
面试题10- I. 斐波那契数列
hanxuwerewolf的博客
03-24 272
""" title:面试题10- I. 斐波那契数列 introduce: 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下： F(0) = 0, F(1)= 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。 答案需要取模 1e...
面试题10：斐波那契数列
Blossom
03-30 761
题目1 该系列文章题目和思路均参考自：《剑指Offer》 解法 思路1（效率较低的思路）：使用递归求解斐波那契数列是很常见的写法，但这种递归方式效率较低，因为在计算的过程中包含了很多重复元素的计算。例如计算n=10时的计算过程如下： 代码实现： public static long fibonacciRecursion(int n) { if (n == 0 ...
从小白到大神都会遇到的经典面试题 —— 斐波那契数列
0 error(s)
05-27 1037
文章目录斐波那契数列是什么斐波那契数列面试常问问法递归解法普通递归方法尾递归法迭代解法更快的解法（一）：数学方法更快的解法（二）：矩阵幂次方（大厂必备）参考文献 写在前面： 博主在春招找实习的过程中呢，百度的二面面试官就让我手撕了跳台阶问题。其本质上呢是斐波那契数列，当时给出了四种解法。但是呢，面试官还是不是很满意。博主苦思冥想也想不出最后一种，最后面试官教了我一种解法，遂连带着一起记录下来。 斐波那契数列是什么 以下内容摘自百度百科： 斐波那契数列（Fibonacci sequence），又称黄金分
fengmin0722#algorithms-1#面试题10- I. 斐波那契数列1
07-25
面试题10- I. 斐波那契数列写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：斐波那契数列由 0 和 1 开
09-斐波那契数列.md
最新发布
03-31
本章将通过多个面试题，为你讲解算法面试题的解题思路，同时复习常用数据结构和算法思维。 ## 为何要考察 如果在短时间之内快速判断一个工程师是否优秀？考察算法是最合理的方式 —— 这是业界多年的经验积累。 ...
JS面试题---关于算法台阶的问题
10-21
这是一个典型的递推问题，与斐波那契数列有密切关系。 斐波那契数列定义为：F(1) = 1, F(2) = 1, F(n) = F(n-1) + F(n-2) (n >= 3)，即每一项是前两项之和。在这个问题中，我们可以将到达第n层楼梯的方法数看作是...
LeetCode算法----斐波那契数列
超越无限_
12-23 447
今天又是摸鱼的一天，来做道题吧！ 求取斐波那契数列第N位的值。 斐波那契数列：每一位的值等于他前两位数字之和。前两位固定 0，1,1,2,3,5,8。。。。 解法一：暴力递归 public static int calculate(int num){ if(num == 0 ){ return 0; } if(num == 1){ return 1; } return calculate(num-1) + calcula
一道斐波纳契数列（Fibonacci Sequence）面试题
sessos的博客
03-12 406
一道斐波纳契数列（Fibonacci Sequence）面试题 直接上题： 直接上答案： #include &lt;iostream&gt; using namespace std; int main() { int f1 = 1,f2=1,n,i; cin &gt;&gt; n; for(i = 2;i &lt; n;i++) { i...
经典面试问题 斐波那契数列
wwxy1995的博客
06-10 569
斐波那契数列的定义是F[N] = F[N-1] + F[N-2] F[0] =F[1] = 1 如果直接用递归的方法求解，画出递归树可得时间复杂度是O(2^n) 使用记忆话递归，即将已经计算出来的状态存下来，如果发现这个答案已经计算过，则不再递归下去，直接用答案，否则递归下去，时间复杂度是O(N)。 自底向上迭代，时间复杂度O(N) 还可以继续优化到O(logN) 优化的方法将矩...
面试题：斐波那契系列
穷B光头
01-25 201
斐波那契数列在很多题中都是隐含的，要先挖掘题目中的规律，才知道这题原来就是个斐波那契数列。 例题1：青蛙跳台阶问题  一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个n级台阶总共有多少种跳法。 思路：如果n是个足够大的数字，那么在跳了1级或者两级之后，还是要重复同样可能的操作。如果跳n级阶梯有f(n)种跳法，那么挑1级，则还有f(n-1)，如果它跳2级，则还有f
面试题之斐波那契数列
Lawrence_121
11-01 724
简介：      斐波那契数列是意大利著名的数学家，他最重要的研究成果是在不定分析和数学论方面，他的斐波那契数列成为世人热衷研究的问题。 *：面试此题的几率也很大。 特点：     a1,a2已知     a(n)=a(n-1)+a(n-2) n>=3 应用：       兔子繁殖问题，树枝问题，上楼方式问题，蜂房问题，声音问题，花瓣问题。。。。。 详解：
【Java】 面试题10：斐波那契数列
小小核桃
03-02 375
面试题10：斐波那契数列 题目一：写一个函数，输入n，求斐波那契数列的第n项。 方法1：递归求解 package jianZhiOffer; import java.util.Scanner; /* * 面试题10：斐波那契数列 * 题目一：写一个函数，输入n，求斐波那契数列的第n项。 */ public class O10Fibonacci { public static int fib...
面试-斐波那契数列
Leo的专栏
10-01 9054
在C语言或者C++的面试中，斐波那契数列是个比较常见的题目
面试题：斐波那契数列
穷B光头
01-24 425
写一个函数，输入n，求斐波那契（Fibonacci）数列的第n项。斐波那契数列的定义如下： f(n)=f(n-1)+f(n-2)  f(0)=0 f(1)=1 思路：教科书上演示递归的方法并不好，因为递归要从上至下到底后再反弹，要空间存储,费时又费力。说明递归方法不好的最好途径就是画树，一目了然，因为使用递归，出现了太多重复计算，而且因此还需占用大量空间。当n=100，递归就明显能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值