完美序列

如果一个序列的相邻两项差的绝对值小于等于1，那么我们说这个序列是完美的。

给出一个有序数列A，求有多少种完美序列排序后和数列A相同。

Input

第一行一个数n（<=30000）表示完美序列的长度
第二行n个数，表示数列A（每个数<=10^9，每个数出现次数<=100）

Output

仅包含一个整数，表示可能的方案总数（对1,000,000,007取模）

Input示例

6
1 1 2 2 3 3

Output示例

12

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long ll;
const int MAXN = 30005;
const int MOD = 1e9 + 7;
int n, type, a[MAXN], num[MAXN];
ll f[MAXN][105][2][2], result, C[130][130], fac[130];

ll q_pow(ll x, ll y)
{
    ll result = 1;
    ll base = x;
    while (y)
    {
        if (y & 1)
        {
            result = (result * base) % MOD;
        }
        y >>= 1;
        base = (base * base) % MOD;
    }
    
    return result;
}

void init()
{
    fac[0] = 1; 
    for (int i = 1; i <= 120; i++)
    {
        fac[i] = (fac[i-1] * i) % MOD;
    }
    for (int i = 0; i <= 110; i++)
    {
        for(int j = 0; j <= i; j++)
        {
            C[i][j] = fac[i] * q_pow(fac[j] * fac[i-j] % MOD, MOD - 2) % MOD;
        }
    }
}

int main()
{
    init();
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    sort(a + 1, a + 1 + n);
    int i = 1;
    while (i <= n)
    {
        int j = i + 1;
        while (j <= n && a[i] == a[j])
        {
            j++;
        }
        if (a[j] - a[i] > 1)
        {
            cout << 0 << endl;
            return 0;
        }
        num[++type] = j - i; 
        i = j;
    }
    f[1][num[1] - 1][1][1]=1;
    for (int i = 1; i < type; i++)
    {
        for (int j = 0; j < num[i]; j++)
        {
            for (int t0 = 0; t0 < 2; t0++) 
            {
                for (int t1 = 0; t1 < 2; t1++)
                {
                    if (f[i][j][t0][t1])
                    {
                        for (int k = 0; k <= j; k++)
                        {
                            for (int k0 = 0; k0 <= t0; k0++) 
                            {
                                for (int k1 = 0; k1 <= t1; k1++) 
                                {
                                    if (k0 + k1 + k && num[i + 1] - (k0 + k1 + k) >= 0)
                                    {    
                                        f[i + 1][num[i + 1] - (k0 + k1 + k)][k0][k1] += (f[i][j][t0][t1] * C[num[i + 1] - 1][k0 + k1 + k - 1] % MOD) * C[j][k] % MOD;
                                        f[i + 1][num[i + 1] - (k0 + k1 + k)][k0][k1] %= MOD;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    for (int i = 0; i < 102; i++)
    {
        for (int j = 0; j < 2; j++) 
        {
            for (int k = 0; k < 2; k++) 
            {
                result = (result + f[type][i][j][k]) % MOD;
            }
        }
    }
    
    cout << result << endl;
    return 0;
}