棋盤遊戲【51nod 1327】【DP+組合數學】

題目鏈接

---

  首先要先強調，排列A(0, 0) = 1，被這個卡了半天。

  然後講一講關於這道題的思路，一開始想的方向是先完美匹配之後再去找增廣路，但是發現一點增廣路可以確定的是被替換，但是不能確定的是方案數，於是，肯定就該利用dp思想來解決該問題了。

  開始想辦法dp，首先，想到的是我們不能去用行來進行約束，因爲行的話沒有確切的約束條件，但是通過每一列最多放一個這則消息，我們可以試着從列來進行展開，我們假設表示到第i列時候，前面還有j個列是空的情況。

  在輸入中的"l, r"表示前l個和後r箇中，各自剛好放有一個，所以對於前l時候，到第l位的時候必須要保證有一個，所以我們可以記錄，"pre[l]++;"這樣的方法，也就是到這一位的時候必須約束上。

  所以，dp的部分轉移方程就可以看出來了。

  當我們排掉左邊部分的約束的時候，dp應該是：，因爲現在到第i+1位的時候，i+1位也還是空位的，然後我們必須從這j+1位裏面取出個，保證合法性。

  但是這時候還是沒有對右邊的約束，所以我們還需要考慮右邊的約束條件。

  因爲是從左到右，但是我們如果用上面記錄約束點的方式，那麼我們應該計算的是累加不合法的數量，保證到第M個的時候，累加不合法數量爲0即可。

  所以，我們還需要控制右邊的“不合法”的數量，這時候先加上，然後最後到第M列的時候統計“0不合法”的答案即可。

  假設表示到第i列的時候，有k個不合法的時候，那麼有狀態轉移方程：這是隻考慮後面的狀態的時候，但是同時考慮左邊的時候，我們還是需要乘上左邊的貢獻，所以我們需要分以下的狀態考慮：

• 放左

因爲放左的時候，不需要考慮右邊的，直接累加不合法數量即可。

• 放右

因爲在這裏，左邊的是直接要保證的，但是第i+1位又是去放右邊的了，所以左邊選j位來放了，然後第i+1位放的到底是中的哪一位呢，這份貢獻也要乘上去。

• 放中

  算了前面兩種貢獻之後，還是少算了一種可能性，就是當還有很多空格的時候，我們可以放空格中，此時左邊的和右邊的都不會加了，而是直接加給空白格。所以我們還是需要知道這段區間的數量，可以直接計算。

直接考慮放在哪塊空白格即可。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define Big_INF 0x3f3f3f3f3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const ll mod = 1e9 + 7;
const int maxN = 55, maxM = 205;
int N, M, l[maxN], r[maxN], pre[maxM] = {0}, suff[maxM] = {0}, mid[maxM] = {0};
ll dp[maxM][maxM][maxN];
ll A[maxM][maxM], jc[maxM];
inline ll fast_mi(ll a, ll b = mod - 2LL)
{
    ll ans = 1;
    while(b)
    {
        if(b & 1) ans = ans * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ans;
}
inline void init()
{
    jc[0] = jc[1] = 1; for(ll i = 2; i<=200; i++) jc[i] = jc[i - 1] * i % mod;
    A[0][0] = 1;
    for(int i=1; i<=200; i++)
    {
        A[i][0] = 1;
        for(int j=1; j<=i; j++)
        {
            A[i][j] = jc[i] * fast_mi(jc[i - j]) % mod;
        }
    }
}
inline void MOOD(ll &x) { if(x >= mod) x %= mod; }
int main()
{
    dp[0][0][0] = 1;
    scanf("%d%d", &N, &M);
    init();
    for(int i=1; i<=N; i++)
    {
        scanf("%d%d", &l[i], &r[i]);
        pre[l[i]]++;
        suff[M - r[i] + 1]++;
        for(int j=l[i] + 1; j<=M - r[i]; j++) mid[j]++;
    }
    for(int i=0; i<M; i++)  //pos i th
    {
        for(int j=0; j<=i; j++) //pre j
        {
            for(int k=0; k<=N; k++) //illege k
            {
                if(dp[i][j][k])
                {
                    //left
                    if(j + 1 >= pre[i + 1])
                        MOOD(dp[i + 1][j + 1 - pre[i + 1]][k + suff[i + 1]] += dp[i][j][k] * A[j + 1][pre[i + 1]] % mod);
                    //right
                    if(j >= pre[i + 1] && k + suff[i + 1] >= 1)
                        MOOD(dp[i + 1][j - pre[i + 1]][k + suff[i + 1] - 1] += dp[i][j][k] * A[j][pre[i + 1]] % mod * (k + suff[i + 1]) % mod);
                    //mid
                    if(j >= pre[i + 1])
                        MOOD(dp[i + 1][j - pre[i + 1]][k + suff[i + 1]] += dp[i][j][k] * A[j][pre[i + 1]] % mod * mid[i + 1] % mod);
                }
            }
        }
    }
    ll ans = 0;
    for(int i=0; i<=M; i++) ans = (ans + dp[M][i][0]) % mod;
    printf("%lld\n", ans);
    return 0;
}