Question

我有这段代码：

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { }

int Fibonacci(int nNumber) {
    if (nNumber == 0)
        return 0;
    if (nNumber == 1)
        return 1;

    return Fibonacci(nNumber-1) + Fibonacci(nNumber-2);
}

void __fastcall TForm1::Button1Click(TObject *Sender) {
    int k=0;
    int val;

    k = StrToInt(Edit1->Text);

    for (int i=0; i < k; i++) {
        val =  Fibonacci(i);
        Form1->ListBox1->Items->Add("F"+IntToStr(i)+"-->"+IntToStr(val));
    }
}

如何制作2个线程，分别计算和打印斐波那契序列的偶数和奇数索引数？

这适用于Builder 6中的练习。

Answer 1

您可以使用仅使用偶数或奇数元素的斐波纳契数的公式。制定这个公式：

f(n) = f(n-1) + f(n-2) [1]
f(n-1) = f(n-2) + f(n-3) [2]
f(n-2) = f(n-3) + f(n-4) [3]

Combining [1] and [2]:
f(n) = 2 * f(n-2) + f(n-3) [4]

Rearranging [3]:
f(n-3) = f(n-2) - f(n-4) [5]

Combining [4] and [5]:
f(n) = 3 * f(n-2) - f(n-4) [6]

现在每个线程可以使用[6]计算偶数或奇数斐波纳契数，而无需等待其他线程的结果。

int Fibonacci(int nNumber) {
    switch (nNumber)
    {
    case 0: return 0;
    case 1: return 1;
    case 2: return 1;
    case 3: return 2;
    default: return 3 * Fibonacci(nNumber-2) - Fibonacci(nNumber-4);
    }
}

然而，这可能会毁掉你的练习，使事情变得比原本简单得多。

Answer 2

有很多方法可以实现这一目标。 Anatolyg的答案非常好;这确实是解决这个问题的理想方式。

但是，就计算效率而言，计算Fibonacci序列的方式存在大问题。

注意：您可以在这里更改几乎所有算法，以便它只计算均值或赔率。这些只是计算斐波那契数的更好方法。

您目前计算数字的方式并不是很有效。使用当前算法计算仅一个数字的算法的时间复杂度已经是O（2 ^ n），甚至不计算循环中的重复调用。一个用于计算斐波那契数的小程序不需要占用整个cpu一分钟来计算前100个数字。

更好的递归算法如下（来自this page）：

unsigned long fib(unsigned int n) {
    return n == 0 ? 0 : fib2(n, 0, 1);
}
unsigned long fib2(unsigned int n, unsigned long p0, unsigned long p1) {
    return n == 1 ? p1 : fib2(n - 1, p1, p0 + p1);
}

我们现在只能在O（n）中计算fib(n)的值，而不是O（2 ^ n）。

这是另一种稍微更高效的O（n）算法：

unsigned long fib(unsigned int n) {
    unsigned long a=0,b=1; 
    for(unsigned long i = 0; i<n; i++)
        a=(b+=a)-a; //there are a number of other variations on this statement,
                    //but that's not the point.
    return a;
}

但是，在您的上下文中，如果您将其用作函数，则仍有另一个问题，即Schlemiel the Painter's Algorithm。这是不好的。由于它必须计算所有数字，每次，你每个数字都取O（n），然后你调用它n次，总时间复杂度为O（n ^ 2）。这仍然比你以前的O（2 ^ n）要好得多，但它仍然不好。

我们可以做得更好。

#INCLUDE <cmath>

#DEFINE (phi) (1.618033988749894848204586834365638117720309179805762862135448L)
#DEFINE (phiC) (–0.618033988749894848204586834365638117720309179805762862135448L)
#DEFINE (root5) (2.236067977499789696409173668731276235440618359611525724270897L)
//using long doubles to minimize the truncation errors,
//as fibonacci numbers can get extremely large

unsigned long fib(unsigned int n) {
    return lrint(((pow(phi,n)-pow(phiC,n))/root5);
}

这个使用Binet's formula来直接计算结果，而不是按顺序计算它们，所以这个特别容易从多个线程运行。

假设目标机器可以在O（1）中计算长双指数，则输出所有斐波那契数的算法仅为O（n）。但是，许多体系结构都不能这样，因此你最有可能最终得到函数的O（n），整个程序的O（n ^ 2）。

我们可以做得更好。

#INCLUDE <iterator>

class FibIterator: public std::Iterator<const unsigned long>{
    unsigned long a=0,b=1;
public:
    std::Iterator& operator++() {
        unsigned long c = b;
        b+=a;
        a=c;
        return(*this);
    }
    std::Iterator& operator--() {
        unsigned long c = a;
        a=b-a;
        b=c;
        return(*this);
    }
    const unsigned long& operator*(){
        return a;
    }
}

（可能不是100％工作，我多年没有编写这么多c ++）

由于您是一个接一个地计算它们，因此无需每次都重新计算所有内容。当您知道前两个斐波纳契数时，计算下一个数字只是O（1）。此代码实际上是Iterator类型，它将迭代斐波那契数列。这也可以作为一个简单的函数实现，但这种方式更方便，因为你只需一次调用即可用它来填充整个列表。

如果您只是将其用作for循环的一部分，则可以仅在O（n）中计算所需的所有数字。

使用两个线程计算Fibonacci序列。

2 个答案: