HDU 5794

HDU 5794 - A Simple Chess
题意：

　　马(象棋)初始位置在(1,1), 现在要走到(n,m), 问有几种走法

　　棋盘上有r个障碍物, 该位置不能走, 并规定只能走右下方

　　

　　数据范围： ( 1 ≤ n,m ≤10^18, 0 ≤ r ≤100 )
    
分析：

　　分析不存在障碍物时的走法规律：
    
                 (1,1)                  　　　　1
              (2,3) (3,2)                      1   1
           (3,5) (4,4) (5,3)              1   2   1
        (4,7) (5,6) (6,5) (7,4)       1   3   3   1
                ......               ......
        发现走法规律是一个斜着的杨辉三角, 即i层第j个的走法数为： C[i,j-1] (组合数)

　　　那么根据换算, 层数 = (x+y+1)/3 - 1 , 个数 = x - (x+y+1)/3

　　　即可得到无障碍物时，(m,n)点的路径数
    
    
    分析障碍物的贡献与障碍物之间的相互影响：

　　　　障碍物(x,y)的贡献 = (1,1)到(x,y)的路径数 * (x,y)到(n,m)的路径数, 后者通过相对位置(平移)计算

　　　　障碍物之间的影响, 即应去掉的重复部分, 也如此计算
    
        
    因为n，m数据范围大， 故计算组合数应用 LUCAS定理

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
const LL MOD = 110119;
long long fac[MOD];
//求a^n % MOD的值
template<class T1, class T2>
T1 QuickPow(T1 x, T2 n, T1 MOD) 
{  
    T1 ans = 1;
    while (n) 
    {  
        if (n & 1) ans = (ans * x) % MOD;
        x = (x * x) % MOD;
        n >>= 1;
    }  
    return ans;  
}
//组合数
//参数为C(n, m) % p (p为质数)
//fac[i]表示i! % p
template<class T, class Type>
T C(Type n, Type m, T p) 
{
    if (n < m) return 0;
    T x = fac[n], y = fac[n-m] * fac[m] % p;
    return x * QuickPow(y, p - 2, p) % p;
}
//生成i! % p (i = 0->p-1)
//配合Lucas定理使用
template<class T>
void ProFac(T *fac, T p) 
{
    fac[0] = 1;
    for (int i = 1; i < (int)p; i++)
        fac[i] = fac[i-1] * i % p;
}
//Lucas定理
//求C(n, m) % p (n, m可以很大, p最大可为1e5, p为质数)
//后面两个参数内部使用，不必考虑
template<class T>
T Lucas(T n, T m, T p) 
{
    if (m == 0)  return 1LL;
    else 
    {
        T res = C(n % p, m % p, p) * Lucas(n / p, m / p, p) % p;
        return res;
    }
}


inline bool change(LL x,LL y, LL &m,LL &n) //将(x,y) 转为 C[b][a]
{
    if((x + y + 1) % 3 != 0 ) return 0;
    LL a = (x + y + 1) / 3;
    if(x < a || y < a) return 0;
    m = x - a;
    n = a - 1;
    return 1;
}

struct CC
{
    LL x, y, a, b;
}g[105];
LL n, m, a, b;
int r, tot;
LL gx[105], gy[105], val[105];
LL ans;

bool cmp(CC a, CC b) 
{
    return a.b < b.b;
}
bool flag;
int main()
{
    ProFac(fac, MOD);
    int tt = 1;
    while (~scanf("%lld%lld%d",&n,&m,&r))
    {
        flag = 0;
        for (int i = 1; i <= r; i++)
        {
            scanf("%lld%lld", &gx[i], &gy[i]);
            if(gx[i] == n && gy[i] == m) flag = 1;
        }
        printf("Case #%d: ", tt++);
        if (flag || !change(n, m, a, b)) //障碍物在 n,m 点,或者不能跳到n,m 
        {
            puts("0"); continue;
        }
        tot = 0;
        for (int i = 1; i <= r; i++)
        {
            if (!change(n - gx[i] + 1,m - gy[i] + 1, g[tot].a, g[tot].b)) continue; //该位置不能影响到 n,m点 
            if (change(gx[i], gy[i], g[tot].a, g[tot].b)) // 有效障碍物点
            {
                g[tot].x = gx[i], g[tot].y = gy[i];
                tot++;
            }
        }
        ans = Lucas(b, a, MOD);//C[b][a]
        sort(g, g + tot, cmp);
        for (int i = 0; i < tot; i++)
        {
            val[i] = Lucas(g[i].b, g[i].a, MOD);//到每个障碍物的的路径数 
        }
        for (int i = 0; i < tot; i++)
        {
            LL a1, b1, tmp;
             if (!change(n - g[i].x + 1, m - g[i].y + 1, a1, b1) ) continue;
            tmp = Lucas(b1, a1, MOD);
            ans = (ans + MOD - (val[i] * tmp % MOD )) % MOD;//减去障碍物贡献 
            for (int j = i + 1; j < tot; j++)
            {
                if ( !change(g[j].x - g[i].x + 1, g[j].y - g[i].y + 1, a1, b1) ) continue;
                tmp = Lucas(b1, a1, MOD);
                val[j] = (val[j] + MOD - (val[i] * tmp % MOD )) % MOD; //减去障碍物之间的影响 
            }
        }
        printf("%lld
", ans);
    }
}