題目描述

n個人在w*h的監獄裡面想要逃跑,已知他們的同夥在座標(bi,h)接應他們,他們現在被關在(ai,1)現在他們必須要到同夥那裡才有逃出去的機會,這n個人又很蠢只會從(x,y)->(x+1,y),(x,y+1)並且這他們走過的路徑不能相交如果相交第一個經過後就會有第二個人經過時候就會有一名獄警在那等他,第二個人就會被抓,假設他們不會同時踩到某個格子，那麼他們的逃跑路線有多少不同的方案數。如果兩個方案不同那麼存在一個人踩的格子至少有一個是另外一個方案的沒踩過

 

輸入

第一行一個t(t<=20)表示測試樣例 
第二行兩個3個正整數n,w,h(n<=100,w,h<=1e9) 
接下來n行每行兩個整數 
ai,bi(ai,bi<=w) 

 

輸出

輸出一個整數表示答案最終結果取膜109*1000003

 

樣例輸入

1
2 4 2
1 2 
3 4

 

樣例輸出

4

思路：

這裡有一個結論，n個起點到n個終點的不相交路徑的種數為：每個起點到每個終點的可能陣列成的n*n的矩陣的行列式。

即求上矩陣行列式，其中e（ai，bi）代表從ai起點到bi終點的可能路徑數量，行列式求解用高斯消元。

顯然現在的問題是求解e。顯然e（a[i],b[j]）= (h - 1 + b[j] - a[i], b[j] - a[i])或者0。

但是a、b、h範圍均為1e9，那麼求解組合數需要用到Lucas定理，但是mod = 109 * 1000003，顯然是個合數，那麼需要先質因數分解（顯然分好了），然後中國剩餘定理合併。

參考：

HDU 5852：Intersection is not allowed!（行列式+逆元求組合數）

hdu 5446 Unknown Treasure（Lucas定理+中國剩餘定理）

程式碼：

#include<set>
#include<map>
#include<stack>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include
 
<algorithm>
typedef long long ll;
using namespace std;
const int maxn = 1e5 + 10;
const int seed = 131;
const ll MOD = 109 * 1000003;
const int INF = 0x3f3f3f3f;
ll a[maxn], b[maxn];
ll e[105][105];
ll prime[maxn], p[maxn], pn;
ll fac[2][1000010];
ll pmul(ll a, ll b, ll p){
    ll ans = 1;
    while(b){
        if(b & 1) ans = ans * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return ans;
}
ll modmul(ll a, ll b, ll p) {
    ll ret = 0;
    while(b) {
        if(b & 1) ret = (ret + a) % p;
        a = (a + a) % p;
        b >>= 1;
    }
    return ret;
}
ll Lucas(ll n, ll m, ll p, int i) {
    ll ret=1;
    while(n && m) {
        ll a = n%p, b = m%p;
        if(a<b) return 0;
        ret = (ret * fac[i][a] * pmul(fac[i][b]*fac[i][a - b] % p, p-2, p)) % p;
        n/=p;
        m/=p;
    }
    return ret;
}

ll exgcd (ll a, ll b, ll &x, ll &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int ans = exgcd ( b , a % b , y , x );
    y -= a / b * x;
    return ans;
}
ll remainder(ll a[], ll m[], int len) {
    ll d, x, y, ret = 0;
    ll M = 1;
    for (int i = 0; i < len; i++) M *= m[i];
    for (int i = 0; i < len; i++) {
        ll w = M / m[i];
        d = exgcd(m[i], w, x, y);
        ret = (ret + modmul(modmul(y, w, M), a[i], M) ) % M;
    }
    return (ret + M) % M;
}
ll guass(int n, ll MOD){
    ll ans = 1, f = 1;
    for(int i = 1; i <= n; i++){
        for(int j = i + 1; j <= n; j++){
            int x = i, y = j;
            while(e[y][i]){
                ll t = e[x][i] / e[y][i];
                for(int k = i; k <= n; k++)
                    e[x][k] = (e[x][k] - e[y][k] * 1LL * t % MOD) % MOD;
                swap(x,y);
            }
            if(x != i){
                for(int k = 1; k <= n; k++)
                    swap(e[i][k], e[j][k]);
                f = -f;
            }
        }
        ans = ans * e[i][i] % MOD;
        if(ans == 0) return 0;
    }
    return (ans * f + MOD) % MOD;
}
void init(){
    memset(prime, 0, sizeof(prime));
    pn = 0;
    for(ll i = 2; i < maxn; i++){
        if(!prime[i]){
            p[pn++] = i;
            for(ll j = i * i; j < maxn; j += i)
                prime[i] = 1;
        }
    }
    fac[0][0] = 1;
    for(int i = 1; i <= 109; i++){
        fac[0][i] = (fac[0][i-1]*i) % 109;
    }
    fac[1][0] = 1;
    for(ll i = 1; i <= 1000003; i++){
        fac[1][i] = (fac[1][i-1]*i) % 1000003;
    }
}
ll solve(ll n, ll m){
    ll ret;
    ll lucas[2];
    ll p[2] = {109, 1000003};
    for(int i = 0; i < 2; i++){
        lucas[i] = Lucas(n, m, p[i], i);
    }
    ret = remainder(lucas, p, 2);
}
int main(){
    init();
    int t;
    scanf("%d", &t);
    while(t--){
        ll n, w, h;
        scanf("%lld%lld%lld", &n, &w, &h);
        for(int i = 1; i <= n; i++)
            scanf("%lld%lld", &a[i], &b[i]);
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n; j++){
                if(b[j] >= a[i]){
                    e[i][j] = solve(h - 1 + b[j] - a[i], b[j] - a[i]);
                }
                else e[i][j] = 0;
            }
        }
        printf("%lld\n", guass(n, MOD));
    }
    return 0;
}