codility: Fibonacci numbers (FibFrog, Ladder)

FibFrog:

The Fibonacci sequence is defined using the following recursive formula:

 

    F(0) = 0
    F(1) = 1
    F(M) = F(M - 1) + F(M - 2) if M >= 2

A small frog wants to get to the other side of a river. The frog is initially located at one bank of the river (position −1) and wants to get to the other bank (position N). The frog can jump over any distance F(K), where F(K) is the K-th Fibonacci number. Luckily, there are many leaves on the river, and the frog can jump between the leaves, but only in the direction of the bank at position N.

The leaves on the river are represented in a zero-indexed array A consisting of N integers. Consecutive elements of array A represent consecutive positions from 0 to N − 1 on the river. Array A contains only 0s and/or 1s:

• 0 represents a position without a leaf;
• 1 represents a position containing a leaf.

The goal is to count the minimum number of jumps in which the frog can get to the other side of the river (from position −1 to position N). The frog can jump between positions −1 and N (the banks of the river) and every position containing a leaf.

For example, consider array A such that:

 

    A[0] = 0
    A[1] = 0
    A[2] = 0
    A[3] = 1
    A[4] = 1
    A[5] = 0
    A[6] = 1
    A[7] = 0
    A[8] = 0
    A[9] = 0
    A[10] = 0

The frog can make three jumps of length F(5) = 5, F(3) = 2 and F(5) = 5.

Write a function:

int solution(vector<int> &A);

that, given a zero-indexed array A consisting of N integers, returns the minimum number of jumps by which the frog can get to the other side of the river. If the frog cannot reach the other side of the river, the function should return −1.

For example, given:

 

    A[0] = 0
    A[1] = 0
    A[2] = 0
    A[3] = 1
    A[4] = 1
    A[5] = 0
    A[6] = 1
    A[7] = 0
    A[8] = 0
    A[9] = 0
    A[10] = 0

the function should return 3, as explained above.

Assume that:

• N is an integer within the range [0..100,000];
• each element of array A is an integer that can have one of the following values: 0, 1.

Complexity:

• expected worst-case time complexity is O(N*log(N));
• expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).

就是个BFS，因为是求最小的步数，所以状态只要记录当前的位置以及走过的步数就好，状态转移的数组是fib数列（最大的fib数不应当大于河岸的长度，也就是A的size），每次找下一个状态的时候用贪心看最远能跳到哪里。

// you can also use includes, for example:
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
vector<int> dynamicFibs(int n) {
    vector<int> fibs;
    fibs.push_back(0);
    fibs.push_back(1);
    for(int i=2;i<=n+2;i++) {
        int tmp = fibs[i-1]+fibs[i-2];
        if(tmp>n+2) {
            break;
        }
        fibs.push_back(tmp);
    }
    return fibs;
}
typedef struct state {
    int pos;
    int step;
}state;
int solution(vector<int> &A) {
    // write your code in C++98
    const int size = A.size();
    if(size==0) {
        return 1;
    }
    vector<int> fibs = dynamicFibs(size);
    int maxAction = fibs.size();
    bool visited[size];
    fill(visited,visited+size,false);
    queue<state> q;
    state start = {-1,0};
    q.push(start);
    while(!q.empty()) {
        state s = q.front();
        q.pop();
        for(int i = maxAction;i>=1;i--) {
            int nextPos = s.pos+fibs[i];
            if(nextPos==size) {
                return s.step+1;
            }
            if(nextPos>size||A[nextPos]==0||visited[nextPos]==true) {
                continue;
            }
            state next;
            next.pos = nextPos;
            next.step = s.step+1;
            q.push(next);
            visited[nextPos] = true;
        }
    }
    return -1;
    
}