已知求斐波那契数列第n项的类（Fib）如下： typedef long long LL; class Fib{ private: int m_n{}; //代表第n项，n<=50 public: Fib(); //用来输入m_n LL getRes();//求第n项 };用c++写出其代码

以下是斐波那契数列第n项的类（Fib）的C++代码：

#include <iostream>
using namespace std;

typedef long long LL;

class Fib{
private:
    int m_n; //代表第n项，n<=50
public:
    Fib(){
        cout << "请输入要求的斐波那契数列的项数n：" << endl;
        cin >> m_n;
    }
    LL getRes(){
        if(m_n <= 0){
            return 0;
        }
        if(m_n == 1 || m_n == 2){
            return 1;
        }
        LL a = 1, b = 1;
        for(int i = 3; i <= m_n; i++){
            LL c = a + b;
            a = b;
            b = c;
        }
        return b;
    }
};

int main(){
    Fib fib;
    cout << "斐波那契数列第" << fib.getRes() << "项为：" << fib.getRes() << endl;
    return 0;
}

这里采用了迭代的方法来求解斐波那契数列，时间复杂度为O(n)。

相关问题

输入 n，求斐波那契数列第 n 项模 9 9 9 7 9997 的值。 斐波那契数列的第一项值为 1 1 ，第二项值为 2 2 。c++

可以使用矩阵快速幂求解斐波那契数列的第 n 项，时间复杂度为 O(logn)。具体实现如下：

#include <iostream>
#include <vector>
using namespace std;

const int MOD = 9997999; // 这里是 9997 * 1000 + 999
typedef vector<vector<int>> Matrix;

// 矩阵乘法
Matrix mul(const Matrix& A, const Matrix& B) {
    int n = A.size(), m = B[0].size(), t = A[0].size();
    Matrix C(n, vector<int>(m));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            for (int k = 0; k < t; k++) {
                C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
            }
        }
    }
    return C;
}

// 矩阵快速幂
Matrix pow(const Matrix& A, int n) {
    if (n == 1) return A;
    Matrix T = pow(A, n / 2);
    T = mul(T, T);
    if (n % 2 == 1) T = mul(T, A);
    return T;
}

int fib(int n) {
    if (n == 1) return 1;
    if (n == 2) return 2;
    Matrix A(2, vector<int>(2));
    A[0][0] = A[0][1] = A[1][0] = 1;
    Matrix B = pow(A, n - 2);
    return (2 * B[0][0] + B[0][1]) % MOD;
}

int main() {
    int n;
    cin >> n;
    cout << fib(n) << endl;
    return 0;
}

需要注意的是，这里的模数不是 9997，而是 9997999，因为 9997 不是质数。另外，由于斐波那契数列的第一项和第二项不是 1 和 1，所以需要特判一下。

c语言 已知一个数列的前三项分别为0、0、1，以后吧的各项都是其相邻的前三项之和。计算并输出该数列前n项的平方根之和sum。例如，当n=10时，程序的输出结果应为：23.197745（用for嵌套循环输出）

在C语言中，我们可以使用动态内存分配和一个循环结构来解决这个问题。这是一个经典的斐波那契数列的问题，不过在这里我们要求的是前n项的平方根之和，而不是直接的斐波那契数列。以下是求解思路及代码：

#include <stdio.h>
#include <math.h> // 引入数学库用于sqrt函数

// 动态内存分配
typedef struct {
    long long fib; // 存储当前的斐波那契数
    int index;   // 当前项的位置
} Fibonacci;

Fibonacci* create_fib(int n) {
    Fibonacci* fibs = (Fibonacci*)malloc(sizeof(Fibonacci) * (n + 1)); // 分配内存
    fibs[0].fib = 0;
    fibs[0].index = 0;
    if (n > 0) {
        fibs[1].fib = 1;
        fibs[1].index = 1;
    }
    return fibs;
}

double sum_of_square_roots(Fibonacci* fibs, int n) {
    double sum = 0;
    for (int i = 0; i < n; i++) {
        sum += sqrt(fibs[i].fib);
    }
    return sum;
}

void print_result(double result) {
    printf("%.6f\n", result); // 输出结果保留六位小数
}

int main() {
    int n = 10;
    Fibonacci* fibs = create_fib(n);
    
    double sum = sum_of_square_roots(fibs, n);
    print_result(sum);

    free(fibs); // 释放内存
    return 0;
}

当你运行这个程序，输入 `n = 10`，它将计算并输出斐波那契数列前10项的平方根之和，大约是23.197745。