Why doesn't this Fibonacci number function work in O (log N)?

Question

So, the Fibonacci number for log (N) is without matrices.

Ni // i-th Fibonacci number
= Ni-1 + Ni-2              // by definition
= (Ni-2 + Ni-3) + Ni-2     // unwrap Ni-1
= 2*Ni-2 + Ni-3            // reduce the equation
= 2*(Ni-3 + Ni-4) + Ni-3   //unwrap Ni-2
                           // And so on
= 3*Ni-3 + 2*Ni-4
= 5*Ni-4 + 3*Ni-5
= 8*Ni-5 + 5*Ni-6

= Nk*Ni-k + Nk-1*Ni-k-1

Now we write a recursive function, where at each step we take k ~ = I / 2.

static long N(long i)
{
    if (i < 2) return 1;
    long k=i/2;
    return N(k) * N(i - k) + N(k - 1) * N(i - k - 1);
}

Run code

Where is the mistake?

Answer 1

You get the recursion formula for the effort: T (n) = 4T (n / 2) + O (1). (apart from the fact that numbers are getting larger, so O (1) is not even executed). From this it is clear that T (n) is not included in O (log (n)). Instead, it follows by the main theorem T (n) in O (n ^ 2).

Btw, this is even slower than the trivial algorithm for calculating all Fibonacci numbers up to n.

Answer 2

N i/2. , N log ₂ N, , "" 4 ^ log ₂ N = O (n ²) , , N . , , O (n). , , , O (log n).

O (n), , :

static long N(long i) {
    if (i<2) {
        return 1;
    }
    long k = i/2;
    long val1;
    long val2;
    val1 = N(k-1);
    val2 = N(k);
    if (i%2==0) {
        return val2*val2+val1*val1;
    }
    return val2*(val2+val1)+val1*val2;
}

2 N , O (n).

Answer 3

public class fibonacci {
public static int count=0;
public static void main(String[] args) {

    Scanner scan = new Scanner(System.in);
    int i = scan.nextInt();
    System.out.println("value of i ="+ i);
    int result = fun(i);
    System.out.println("final result is " +result);

}
public static int fun(int i) {
    count++;
    System.out.println("fun is called and count is "+count);
    if(i < 2) {
        System.out.println("function returned");
        return 1;
    }
    int k = i/2;
    int part1 = fun(k);
    int part2 = fun(i-k);
    int part3 = fun(k-1);
    int part4 = fun(i-k-1);
    return ((part1*part2) + (part3*part4)); /*RESULT WILL BE SAME FOR BOTH METHODS*/
    //return ((fun(k)*fun(i-k))+(fun(k-1)*fun(i-k-1)));
}

}

, java. , O (N ^ 2), . - O (N ^ 2), , (, ) .

, fun (int i) .

OUTPUT

, , , , O (N ^ 2), O (LogN).

, .

T (N) = 4 * T (N/2) + O (1)

O (1) - . .

T(n) = aT(n/b) + f(n) where a >= 1 and b > 1

:

• f (n) = Θ (nc), c < Logba T (n) = Θ (nLogba)
• f (n) = Θ (nc), c = Logba, T (n) = Θ (ncLog n)
• f (n) = Θ (nc), c > Logba, T (n) = Θ (f (n))

a = 4, b = 2 c = 0. 1 c < logba => 0 < 2 ( 2 2), , T(n) = O(n^2).

, -, :

Answer 4

, O (log n), . , N (k) * N (i-k), (k = i-k), . , .

What you need is called memoization . That is, save all the values ​​that you have already calculated, and if it appears again, you will get it in O (1).

Here is an example

const int MAX = 10000;

// memoization array
int f[MAX] = {0};

// Return nth fibonacci number using memoization
int fib(int n) {
    // Base case
    if (n == 0)
        return 0;
    if (n == 1 || n == 2)
        return (f[n] = 1);

    // If fib(n) is already computed
    if (f[n]) return f[n];

    // (n & 1) is 1 iff n is odd
    int k = n/2;

    // Applying your formula
    f[n] = fib(k) * fib(n - k) + fib(k - 1) * fib(n - k - 1);

    return f[n];
}