51Nod - 1296 有限制的排列

计算整数集合{1,2,3,4, .... N }满足下列条件的的排列个数:

 

在位置a1, a2, ..., aK小于其邻居（编号从0开始）。

在位置b1, b2, ..., bL大于其邻居。

 

输出符合条件的排列数量Mod 1000000007的结果。例如：N = 4，a = {1}, b = {2}，符合条件的排列为：

 

2 1 4 3

3 2 4 1

4 2 3 1

3 1 4 2

4 1 3 2

Input

第1行：3个数N, K, L，分别表示数组的长度，限制a的长度，限制b的长度(1 <= N <= 5000, 1 <= K, L <= N)。
第2 - K + 1行：每行一个数，对应限制a的位置(1 <= ai <= N - 2)
第K + 2 - K + L + 1行：每行一个数，对应限制b的位置(1 <= bi <= N - 2)

Output

输出符合条件的排列数量Mod 1000000007的结果。

Input示例

4 1 1
1
2

Output示例

5

思路：

数位dp。

dp[i][j]表示前i位并且最后一位值为j时的排列方式数量。

sum[i]表示前一轮最后一位小于等于i时的排列方式数量。

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

const int MAXN = 5e3 + 10;
const int MOD = 1e9 + 7;

int N, K, L;
int state[MAXN], sum[MAXN];
int dp[MAXN][MAXN];

int main()
{
	cin >> N >> K >> L;

    int a;
    for (int i = 0; i < K; i++)
    {
		cin >> a;
        state[a + 1] = 1;
        state[a + 2] = 2;
    }
    for (int i = 0; i < L; i++)
    {
		cin >> a;
        state[a + 1] = 2;
        state[a + 2] = 1;
    }

    sum[0] = 0;
    dp[1][1] = sum[1] = 1;

    for (int i = 2; i <= N; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            if (state[i] == 0)
            {
                dp[i][j] = sum[i - 1];
            }
            else if (state[i] == 1)
            {
                dp[i][j] = ((sum[i - 1] - sum[j - 1]) % MOD + MOD) % MOD;
            }
            else
            {
                dp[i][j] = sum[j - 1];
            }
        }
        
        for (int k = 1; k <= i; k++)
        {
            sum[k] = (sum[k-1] + dp[i][k]) % MOD;
        }
    }
    cout << sum[N] << endl;

    return 0;
}