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 Scala (2.11.7) (judge verdict: Time Limit Exceeded)

import java.util.Scanner

object MyMath {

  def mpow(m: Long)(b: Long, e: Long): Long = {
    def doMpow(r: Long, b: Long, e: Long): Long = {
      if (e == 0) r
      else {
        val r1 = if ((e & 1) == 1) (r * b) % m else r
        doMpow(r1, (b * b) % m, e >> 1)
      }
    }
    doMpow(1, b, e)
  }

  def mfact(m: Long)(n: Long, nend: Long = 1): Long = {
    def doMfact(n: Long, r: Long): Long = {
      if (n < nend) r
      else doMfact(n - 1, (r * n) % m)
    }
    doMfact(n, 1)
  }

  def mconb(m: Long)(n: Long, k: Long): Long = {
    def pow: (Long, Long) => Long = mpow(m)
    def fact: (Long, Long) => Long = mfact(m)

    (fact(n, n - k + 1) * pow(fact(k, 1), m - 2)) % m
  }

}

object Main {
  def main(args: Array[String]) {
    if (args.length > 0 && args(0) == "TEST") {
      println(test())
    } else {
      val input = io.Source.stdin.getLines().mkString("\n")
      println(solve(input).trim())
    }
  }

  val mod = 1000000007L
  def comb: (Long, Long) => Long = MyMath.mconb(mod)

  def calcSteps(stairs: Long, twoSteps: Long): Long = comb(stairs - twoSteps, twoSteps)
  def calcPatterns(stairs: Long): Long = {
    if (stairs < 0) 0
    else {
      var sum: Long = 0
      (0L to stairs / 2).foreach(twoSteps => sum = (sum + calcSteps(stairs, twoSteps)) % mod)
      sum
    }
  }

  def solve(input: String): String = {
    val s: Scanner = new Scanner(input)
    val n, m = s.nextInt
    var aprev = -1L
    var p = 1L
    var a = 0L
    for (_ <- 1 to m) {
      a = s.nextInt
      p = (p * calcPatterns(a - 2 - aprev)) % mod
      aprev = a
    }
    p = (p * calcPatterns((n + 1) - 2 - aprev)) % mod
    p.toString
  }

  val tests = List(
    """6 1
      |3
    """.stripMargin -> """4""",
    """10 2
      |4
      |5
    """.stripMargin -> """0""",
    """100 5
      |1
      |23
      |45
      |67
      |89
    """.stripMargin -> """608200469"""
  )

  def test(): String = tests.map { case (i, o) => (i.trim(), o.trim()) }
    .zipWithIndex.map {
    case ((input, outputExpect), i) =>
      val output = solve(input).trim()
      val tnum = i + 1
      s"test$tnum:" + (
        if (output == outputExpect) "Passed"
        else s"Failed\nexpect:\n$outputExpect\noutput:\n$output")
  }
    .mkString("\n")
}