将数字分解为斐波那契数字的程序

Question

I am struggling to write a program in C. I want to disintegrate a number (only if it can be disintegrated) into a smaller numbers which can only be fibonacci numbers. For example :

If I have a number n = 20 then my output should be 1,1,2,3,5,8 so when I add these smaller fibonacci numbers it gives me number 20.

Answer 1

Every integer has a representation as a sum of unique Fibonacci numbers. This is easy to prove by induction: if such a representation exists for all numbers up to Fib(n), then Fib(n)+k for k in 1, 2, ..., Fib(n-1) has the representation of Fib(n) + (representation for k). The proof suggests a simple recursive algorithm for finding the presentation for N: pick the greatest Fibonacci number that is less than N, say it's Fib(k). Then find the representation for N-Fib(k).

Answer 2

It can be reduced to subset-sum problem , where the set is the fibonacci numbers smaller/equals the given number.

First generate all numbers smaller/equals the given number n . C-like pseudo code:

int i = 1;
int* arr = //sufficiently large array
arr[0] = arr[1] = 1;
while (arr[i] <= n) { 
    i++;
    arr[i] = arr[i-1] + arr[i-2];
}

After this, you have arr that contains all "candidates", and need to invoke subset-sum algorithm to solve it, using the following recursive calls

D(x,i) = false   x<0
D(0,i) = true
D(x,0) = false   x != 0
D(x,i) = D(x,i-1) OR D(x-arr[i]-1,i)

You later, just need to retrace your steps and find out the actual number used by the DP:

Pseudo code:

x = n;
i = number_of_candidates;
while (i>0) {
   if (x >= arr[i] && DP[i][x-arr[i]]) { 
        //arr[i] is in the solution, add it
        x = x-arr[i];
    }
    i--; //do it for both cases, successful 'if' or not.
}

Total complexity of the answer is O(nlogn) , and the bottleneck is the DP solution.
Note that the number of "candidates" is in O(logn) , since the i th fibonacci number is in O(phi^i) .