Language: C++

#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pll = pair<ll, ll>;

// Modulo.h start----------------------------------------

#pragma once

#include <vector>

unsigned int mod;
struct Modint;
std::vector<Modint> fact_mod;
std::vector<Modint> rev_fact_mod;

using namespace std;

template<typename Tint>
Tint gcd(Tint a, Tint b) {
	// O(log max(a,b))
	a = abs(a);
	b = abs(b);
	return b != 0 ? gcd(b, a % b) : a;
}

template<typename Tint>
Tint lcm(Tint a, Tint b) {
	return a / gcd(a, b) * b;
}

// a x + b y = gcd(a, b)
int extgcd(const unsigned int a, const unsigned int b, int &x, int &y) {
	// O(log max(a,b))
	int g = a; x = 1; y = 0;
	if (b != 0) g = extgcd(b, a % b, y, x), y -= (a / b) * x;
	return g;
}

void set_mod(const unsigned int m) {
	mod = m;
}
void set_mod(const int m) {
	if (m > 0)
		set_mod((unsigned int)m);
	else
		cout << "Error in set_mod" << endl;
}

unsigned int inv_mod(const unsigned int a) {
	int x, y;
	if (extgcd(a, mod, x, y) == 1)
		return (unsigned int)(((long long)x + mod) % mod);
	else // unsolvable
		return 0;
}

struct Modint {
	unsigned int value;
	Modint() { }
	Modint(unsigned int value) : value(value % mod) { }
	Modint(int value) : Modint((unsigned int)(value % mod + mod)) {	}
	Modint(unsigned long long value) : Modint((unsigned int)(value % mod)) { }
	Modint(long long value) : Modint((unsigned int)(value % mod + mod)) { }
	Modint(const Modint& rhs) : Modint(rhs.value) { }
	bool operator==(const Modint& rhs) const;
	inline bool operator!=(const Modint& rhs) const
	{
		return !(*this == rhs);
	}
	Modint& operator+=(const Modint& rhs);
	Modint& operator+=(const unsigned int rhs);
	Modint& operator+=(const int rhs);
	Modint& operator+=(const unsigned long long rhs);
	Modint& operator+=(const long long rhs);
	Modint& operator-=(const Modint& rhs);
	Modint& operator-=(const unsigned int rhs);
	Modint& operator-=(const int rhs);
	Modint& operator-=(const unsigned long long rhs);
	Modint& operator-=(const long long rhs);
	Modint& operator*=(const Modint& rhs);
	Modint& operator*=(const unsigned int rhs);
	Modint& operator*=(const int rhs);
	Modint& operator*=(const unsigned long long rhs);
	Modint& operator*=(const long long rhs);
	Modint& operator/=(const Modint& rhs);
	Modint& operator/=(const unsigned int rhs);
	Modint& operator/=(const int rhs);
	Modint& operator/=(const unsigned long long rhs);
	Modint& operator/=(const long long rhs);
};
bool Modint::operator==(const Modint& rhs) const
{
	return value == rhs.value;
}
Modint& Modint::operator+=(const unsigned int rhs)
{
	unsigned long long tmp = this->value;
	tmp += rhs;
	tmp %= mod;
	this->value = (unsigned int)tmp;
	return *this;
}
Modint& Modint::operator+=(const Modint& rhs)
{
	(*this) += rhs.value;
	return *this;
}
Modint& Modint::operator+=(const int rhs)
{
	(*this) += (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator+=(const unsigned long long rhs)
{
	(*this) += (unsigned int)(rhs % mod);
	return *this;
}
Modint& Modint::operator+=(const long long rhs)
{
	(*this) += (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator-=(const Modint& rhs)
{
	(*this) -= rhs.value;
	return *this;
}
Modint& Modint::operator-=(const unsigned int rhs)
{
	*this += mod - rhs % mod;
	return *this;
}
Modint& Modint::operator-=(const int rhs)
{
	*this -= (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator-=(const unsigned long long rhs)
{
	(*this) -= (unsigned int)(rhs % mod);
	return *this;
}
Modint& Modint::operator-=(const long long rhs)
{
	(*this) -= (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator*=(const Modint& rhs)
{
	(*this) *= rhs.value;
	return *this;
}
Modint& Modint::operator*=(const unsigned int rhs)
{
	unsigned long long tmp = this->value;
	tmp *= rhs;
	tmp %= mod;
	this->value = (unsigned int)tmp;
	return *this;
}
Modint& Modint::operator*=(const int rhs)
{
	(*this) *= (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator*=(const unsigned long long rhs)
{
	(*this) *= (unsigned int)(rhs % mod);
	return *this;
}
Modint& Modint::operator*=(const long long rhs)
{
	(*this) *= (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator/=(const Modint& rhs)
{
	(*this) /= rhs.value;
	return *this;
}
Modint& Modint::operator/=(const unsigned int rhs)
{
	*this *= inv_mod(rhs);
	return *this;
}
Modint& Modint::operator/=(const int rhs)
{
	*this /= (unsigned int)(rhs % mod + mod);
	return *this;
}
Modint& Modint::operator/=(const unsigned long long rhs)
{
	*this /= (unsigned int)(rhs % mod);
	return *this;
}
Modint& Modint::operator/=(const long long rhs)
{
	*this /= (unsigned int)(rhs % mod + mod);
	return *this;
}
const Modint operator + (const Modint& lhs, const Modint& rhs) {
	return Modint(lhs) += rhs;
}
const Modint operator + (const Modint& lhs, unsigned int rhs) {
	return Modint(lhs) += rhs;
}
const Modint operator + (unsigned int lhs, const Modint& rhs) {
	return Modint(lhs) += rhs;
}
const Modint operator - (const Modint& lhs, const Modint& rhs) {
	return Modint(lhs) -= rhs;
}
const Modint operator - (const Modint& lhs, unsigned int rhs) {
	return Modint(lhs) -= rhs;
}
const Modint operator - (unsigned int lhs, const Modint& rhs) {
	return Modint(lhs) -= rhs;
}
const Modint operator * (const Modint& lhs, const Modint& rhs) {
	return Modint(lhs) *= rhs;
}
const Modint operator * (const Modint& lhs, unsigned int rhs) {
	return Modint(lhs) *= rhs;
}
const Modint operator * (unsigned int lhs, const Modint& rhs) {
	return Modint(lhs) *= rhs;
}
const Modint operator / (const Modint& lhs, const Modint& rhs) {
	return Modint(lhs) /= rhs;
}
const Modint operator / (const Modint& lhs, unsigned int rhs) {
	return Modint(lhs) /= rhs;
}
const Modint operator / (unsigned int lhs, const Modint& rhs) {
	return Modint(lhs) /= rhs;
}
ostream& operator<<(std::ostream& lhs, const Modint& rhs)
{
	lhs << rhs.value;
	return lhs;
}

Modint pow_mod(const Modint& x, const unsigned int k) { //x^k (mod)
	if (k == 0)     return Modint(1);
	if (k % 2 == 0) return pow_mod(x*x, k / 2);
	else            return x * pow_mod(x, k - 1);
}
Modint pow_mod(const unsigned int x, const unsigned int k) {
	return pow_mod(Modint(x), k);
}

std::vector<Modint> set_fact_mod(unsigned int n) {
	fact_mod = vector<Modint>(n + 1);
	fact_mod[0] = 1;
	for (unsigned int i = 1; i <= n; i++)
	{
		fact_mod[i] = fact_mod[i - 1] * i;
	}
	return fact_mod;
}

std::vector<Modint> set_rev_fact_mod(unsigned int n) {
	rev_fact_mod = vector<Modint>(n + 1);
	rev_fact_mod[n] = 1 / fact_mod[n];
	for (int i = n - 1; i >= 0; i--)
	{
		rev_fact_mod[i] = rev_fact_mod[i + 1] * (unsigned int)(i + 1);
	}
	return rev_fact_mod;
}

Modint combination_mod_precalculation(unsigned int n, unsigned int r) {
	//set mod, fact_mod, rev_fact_mod
	return fact_mod[n] * rev_fact_mod[r] * rev_fact_mod[n - r];
}

Modint combination_mod_straightforward(unsigned long long n, unsigned long long r) { //mod is prime
	if (r * 2 > n) r = n - r;
	Modint numerator = 1;
	Modint denominator = 1;
	for (unsigned long long i = 1; i <= r; ++i) {
		numerator *= n - i + 1;
		denominator *= i;
	}
	return numerator / denominator;
}

// Modulo.h end----------------------------------------------
#define MOD 1000000007
int N, M;
vector<int> a;

void make_f(Modint f) {
	f[0] = f[1] = 1;
	for (int i = 2; i <= N; i++)
		f[i] = f[i - 2] + f[i - 1];
}

int main() {
	set_mod(MOD);
	Modint f[10009];
	cin >> N >> M;
	a.push_back(-1);
	for (int i = 1; i <= M; i++) {
		int ta;
		cin >> ta;
		a.push_back(ta);
	}
	a.push_back(N + 1);
	make_f(f);

	Modint ans = 1;
	for (int i = 0; i < M + 1; i++)
	{
		if (a[i] == a[i + 1])
			continue;
		const int step = a[i + 1] - a[i] - 2;
		if (step >= 0)
			ans *= f[step];
		else {
			ans = 0;
			break;
		}
	}

	cout << ans << endl;
	return 0;
}


Compiler output:
a.cc:10:9: warning: #pragma once in main file
   10 | #pragma once
      |         ^~~~
a.cc: In function 'void make_f(Modint)':
a.cc:297:10: error: no match for 'operator[]' (operand types are 'Modint' and 'int')
  297 |         f[0] = f[1] = 1;
      |          ^
a.cc:297:17: error: no match for 'operator[]' (operand types are 'Modint' and 'int')
  297 |         f[0] = f[1] = 1;
      |                 ^
a.cc:299:18: error: no match for 'operator[]' (operand types are 'Modint' and 'int')
  299 |                 f[i] = f[i - 2] + f[i - 1];
      |                  ^
a.cc:299:25: error: no match for 'operator[]' (operand types are 'Modint' and 'int')
  299 |                 f[i] = f[i - 2] + f[i - 1];
      |                         ^
a.cc:299:36: error: no match for 'operator[]' (operand types are 'Modint' and 'int')
  299 |                 f[i] = f[i - 2] + f[i - 1];
      |                                    ^
a.cc: In function 'int main()':
a.cc:313:16: error: conversion from 'Modint [10009]' to 'Modint' is ambiguous
  313 |         make_f(f);
      |                ^
a.cc:66:9: note: candidate: 'Modint::Modint(long long int)' (near match)
   66 |         Modint(long long value) : Modint((unsigned int)(value % mod + mod)) { }
      |         ^~~~~~
a.cc:66:9: note:   conversion of argument 1 would be ill-formed:
a.cc:313:16: error: invalid conversion from 'Modint*' to 'long long int' [-fpermissive]
  313 |         make_f(f);
      |                ^
      |                |
      |                Modint*
a.cc:65:9: note: candidate: 'Modint::Modint(long long unsigned int)' (near match)
   65 |         Modint(unsigned long long value) : Modint((unsigned int)(value % mod)) { }
      |         ^~~~~~
a.cc:65:9: note:   conversion of argument 1 would be ill-formed:
a.cc:313:16: error: invalid conversion from 'Modint*' to 'long long unsigned int' [-fpermissive]
  313 |         make_f(f);
      |                ^
      |                |
      |                Modint*
a.cc:64:9: note: candidate: 'Modint::Modint(int)' (near match)
   64 |         Modint(int value) : Modint((unsigned int)(value % mod + mod)) { }
      |         ^~~~~~
a.cc:64:9: note:   conversion of argument 1 would be ill-formed:
a.cc:313:16: error: invalid conversion from 'Modint*' to 'int' [-fpermissive]
  313 |         make_f(f);
      |                ^
      |                |
      |                Modint*
a.cc:63:9: note: candidate: 'Modint::Modint(unsigned int)' (near match)
   63 |         Modint(unsigned int value) : value(value % mod) { }
      |         ^~~~~~
a.cc:63:9: note:   conversion of argument 1 would be ill-formed:
a.cc:313:16: error: invalid conversion from 'Modint*' to 'unsigned int' [-fpermissive]
  313 |         make_f(f);
      |                ^
      |                |
      |                Modint*
a.cc:67:9: note: candidate: 'Modint::Modint(const Modint&)'
   67 |         Modint(const Modint& rhs) : Modint(rhs.value) { }
      |         ^~~~~~
a.cc:67:30: note:   no known conversion for argument 1 from 'Modint [10009]' to 'const Modint&'
   67 |         Modint(const Modint& rhs) : Modint(rhs.value) { }
      |                ~~~~~~~~~~~~~~^~~
a.cc:62:9: note: candidate: 'Modint::Modint()'
   62 |         Modint() { }
      |         ^~~~~~
a.cc:62:9: note:   candidate expects 0 arguments, 1 provided
a.cc:296:20: note:   initializing argument 1 of 'void make_f(Modint)'
  296 | void make_f(Modint f) {
      |             ~~~~~~~^