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 Rust (1.15.1) (judge verdict: Accepted)


macro_rules! fn_memo{
    ($fun:ident : $memo:ident ( $($param:ident : usize),* ) -> $out:ty $body:block) => {
        fn $fun($memo:&mut memo_inner!(type $out; $($param),*), $($param : usize),*) -> $out $body
    };
    ($fun:ident : $memo:ident ( $($eparam:ident : $epty:ty),* ; $($param:ident : usize),* ) -> $out:ty $body:block) => {
        fn $fun($memo:&mut memo_inner!(type $out; $($param),*), $($eparam:$epty),* , $($param : usize),*) -> $out $body
    };
}
macro_rules! memo{
    ($fun:ident : $memo:ident ( $($inf_arg:expr),* ) -> $out:ty) => {
        let mut $memo = &mut memo_inner!(vec $out; $($inf_arg),*);
    };
}
macro_rules! memo_inner {
    (type $out:ty ; $param:ident) => {
        Vec<Option<$out>>
    };
    (type $out:ty ; $param:ident, $($p:ident),*) => {
        Vec<fn_vec!($out; $($p),*)>
    };
    (vec $out:ty; $marg:expr) => {
        vec![None as Option<$out>; $marg]
    };
    (vec $out:ty; $marg:expr, $(m:expr),*) => {
        vec![memo!($out; $($m),*); $marg]
    };
}
macro_rules! get{
    ($fun:ident : $memo:ident ( $($arg:expr),* )) => {{
        if $memo$([$arg])*.is_none() {
            $memo$([$arg])* = Some($fun($memo, $($arg),*));
        }
        $memo$([$arg])*.unwrap()
    }};
    ($fun:ident : $memo:ident ( $($earg:expr),* ; $($arg:expr),* )) => {{
        if $memo$([$arg])*.is_none() {
            $memo$([$arg])* = Some($fun($memo, $($earg),* , $($arg),*));
        }
        $memo$([$arg])*.unwrap()
    }};
}

fn main(){
    let mut buf = String::new();
    use std::io::Read;
    std::io::stdin().read_to_string(&mut buf);
    let mut sw = buf.split_whitespace();
    
    let n: usize = sw.next().unwrap().parse().ok().unwrap();
    let m: usize = sw.next().unwrap().parse().ok().unwrap();
    let mut broken = vec![false; n+1];
    for _ in 0..m {
        let a:usize = sw.next().unwrap().parse().ok().unwrap();
        broken[a] = true;
    }
    let broken = broken;
    
    memo!{ solve:sm(100_001) -> u64 };
    println!("{}", get!{ solve:sm( &broken; n ) });
}

fn_memo!{ solve:sm( broken: &Vec<bool>; n:usize ) -> u64 {
    if broken[n] {
        0
    } else if n <= 1 { 
        1
    } else {
        ((get!{solve:sm(broken; n-1)}) + (get!{solve:sm(broken; n-2)})) % 1_000_000_007
    }
}}