Problem:
Score : 300 points

Problem Statement

There is a staircase with N steps. Takahashi is now standing at the foot of the stairs, that is, on the 0-th step.
He can climb up one or two steps at a time.

However, the treads of the a_1-th, a_2-th, a_3-th, \ldots, a_M-th steps are broken, so it is dangerous to set foot on those steps.

How many are there to climb up to the top step, that is, the N-th step, without setting foot on the broken steps?
Find the count modulo 1\ 000\ 000\ 007.

Constraints

1 \leq N \leq 10^5

0 \leq M \leq N-1

1 \leq a_1 < a_2 < ... < a_M \leq N-1

Input

Input is given from Standard Input in the following format:

N M
a_1
a_2
.
.
.
a_M

Output

Print the number of ways to climb up the stairs under the condition, modulo 1\ 000\ 000\ 007.

Sample Input 1

6 1
3

Sample Output 1

4

There are four ways to climb up the stairs, as follows:

0 \to 1 \to 2 \to 4 \to 5 \to 6

0 \to 1 \to 2 \to 4 \to 6

0 \to 2 \to 4 \to 5 \to 6

0 \to 2 \to 4 \to 6

Sample Input 2

10 2
4
5

Sample Output 2

0

There may be no way to climb up the stairs without setting foot on the broken steps.

Sample Input 3

100 5
1
23
45
67
89

Sample Output 3

608200469

Be sure to print the count modulo 1\ 000\ 000\ 007.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.Scanner;

public class Main {

    public static Long[] patterns;

    // f(1) = 1
    // f(2) = 2
    // f(x) = f(x-1) + f(x-2)
    public static Long temp2( long x ){
        if( x <= 2 ) {
            return x;
        }
        return temp( x - 1 , x - 2);
    }

    // f(x) = f(x-1) + f(x-2);
    // f(x) = af(2) + bf(1);
    public static long temp( long x , long y ){
        if( 3 <= x ){
            if( patterns[(int)x] == null ){
                long t = temp( x - 1 , x - 2 );
                patterns[(int)x] = t;
                x = t;
            }
            else {
                x = patterns[(int)x];
            }
        }
        if( 3 <= y ){
            if( patterns[(int)y] == null ){
                long t = temp( y - 1 , y - 2 );
                patterns[(int)y] = t;
                y = t;
            }
            else {
                y = patterns[(int)y];
            }
        }
        return x + y;
    }

    public static void main( String[] args ){

        Scanner in = new Scanner(System.in);

        String[] params = in.nextLine().split(" ");
        int n = Integer.parseInt(params[0]);
        int m = Integer.parseInt(params[1]);

        patterns = new Long[ n ];

        int[] as = new int[m];
        int broken = -1;
        boolean end = false;
        for( int i = 0 ; i < m ; i++ ){
            as[i] = Integer.parseInt(in.nextLine());
            if( broken == -1 )broken = as[i];
            else if( broken + 1 == as[i] ){
                end = true;
            }
            else {
                broken = as[i];
            }
        }

        if( end ){
            System.out.println(0);
            return;
        }

        long pattern = 1;
        int start = 0;
        for( int i = 0 ; i < m ; i++ ){
            int step = as[i] - start - 1;
            if( step > 1 )pattern *= temp2( (long)step );
            start = as[i] + 1;
        }
        int step = n - start;
        pattern *= temp2( (long)step );

        System.out.println( pattern % 1000000007);

    }
}