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 Ruby (2.7.1) (judge verdict: Accepted)

#!/usr/bin/env ruby

require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.chomp.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

class Combination
  def initialize(n, mod)
    @mod = mod
    @fac, @finv, @inv = Array.new(3) { [] }
    @fac[0] = @fac[1] = 1
    @finv[0] = @finv[1] = 1
    @inv[1] = 1
    i = 2
    while i <= n
      @fac[i] = @fac[i - 1] * i % @mod
      @inv[i] = @mod - @inv[@mod % i] * (@mod / i) % @mod
      @finv[i] = @finv[i - 1] * @inv[i] % @mod
      i += 1
    end
  end

  def nCk(n, k)
    return 0 if (n < k) || (n < 0 || k < 0)

    @fac[n] * (@finv[k] * @finv[n - k] % @mod) % @mod
  end
end

N, M = get_ints
A = []
M.times do |i|
  A[i] = get_int
end
MOD = 10**9 + 7

ax = A + [N+1]

if ax.each_cons(2).any? { |a, b| b - a == 1}
  puts 0
else
  sum = 1
  cur = 0
  max_n = (ax.each_cons(2).map { |a, b| b - a - 2 } + [ax.first-1]).max
  combination = Combination.new(max_n, MOD)

  ax.each do |a|
    x = a - cur - 1
    if x <= 0
      cur = a + 1
      next
    end

    stock = 0
    i = x
    while i > x / 2
      stock += combination.nCk(i, x - (x-i) * 2)
      i -= 1
    end
    if x % 2 == 0
      stock += 1
    end
    sum = sum * stock % MOD
    cur = a + 1
  end
  puts sum
end