HDU 5794 A Simple Chess 16多校6 dp 容斥 lucas

题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=5794

题意：给一个二维直角坐标系下的点(n,m)（1<=n，m<=10^18）和另外r（0<=r<=100）个点。一个棋子从(1,1)点走向(n,m)，走法规定如下，设当前点为(x1,y1)，棋子可以走到(x2,y2)当且仅当(x2-x1)^2+(y2-y1)^2==5且x1<x2,y1<y2。

问棋子不经过障碍点走到点(n,m)的方案数。

思路：

对于我这个蒟蒻，觉得这是一个好题。比赛的时候一个小时我们队就做出了1001和1003，接下来挂机4个小时…………（满脸黑线）

知道了思路之后其实很简单，r最大只有100，应该从这里入手，设dp[i]的含义为： 不经过其他障碍点，从(1,1)点走到i点的方案数。则dp[i]可初始化为（(1,1)点到第i个点的方案数），状态转移方程dp[i]=dp[i]-（第j个点到第i个点的方案数）*dp[j]，其中j 是在i之前的点。（就是把r个点按x，y排序，一个O(r^2）的二重循环）。

某点走到某点的方案数就是一个组合数，不理解的话，画图模拟下就可以很快理解。

这题还有一个问题就是数据范围太大，组合数很难计算，可以使用Lucas定理（详见代码），此法在O（mod）的预处理后，有着（以mod为底的）log级别的速度，很厉害。之前没有接触过，这次遇到了也算有收获。

自己在读入点时就去掉了很多不符合要求的点，在对点排序后，把(n,m)点放在了node数组的后面，两个for枚举点的时候，也用二维坐标系的一些知识，去掉了不符合要求的点。详见代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<cstdlib>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define lowbit(x) (x&(-x))
typedef long long LL;
inline void fre1(){freopen("input.txt","r",stdin);/*freopen("output.txt","w",stdout);*/}
inline void fre2(){fclose(stdin);/*fclose(stdout);*/}
const int MAXN=100+50;
const double EPS=1e-8;
const int MOD=110119;
struct Node{
    LL x,y;
    bool operator <(const Node& rhs) const{
        return x<rhs.x||(x==rhs.x&&y<rhs.y);
    }
}node[MAXN];
LL dp[MAXN],fac[MOD+5];

LL powmod(LL a,LL b){
    LL ret=1;
    for(;b;b>>=1){
        if(b&1) ret=(ret*a)%MOD;
        a=(a*a)%MOD;
    }
    return ret;
}
LL Lucas(LL n,LL m){
    LL ret=1;
    while(n&&m){
        LL a=n%MOD,b=m%MOD;
        if(a<b) return 0;
        ret=(ret*fac[a]*powmod(fac[b]*fac[a-b]%MOD,MOD-2))%MOD;
        n/=MOD;m/=MOD;
    }
    return ret;
}

int main()
{
    fac[0]=1;
    for(int i=1;i<=MOD;++i) fac[i]=(fac[i-1]*i)%MOD;
    LL n,m,x,y;
    int kase=0,r;
    while(~scanf("%I64d%I64d%d",&n,&m,&r)){
        int tot=0;
        bool flag=false;
        if((n+m)%3!=2) flag=true;
        if(m>2*n-1) flag=true;
        if(2*m<n+1) flag=true;
        for(int i=0;i<r;++i){
            scanf("%I64d%I64d",&x,&y);
            if(x==n&&y==m) flag=true;
            if(flag) continue;
            if((x+y)%3!=2) continue;
            if(y>2*x-1) continue;
            if(2*y<x+1) continue;
            node[tot++].x=x;
            node[tot-1].y=y;
        }
        if(flag){
            printf("Case #%d: 0\n",++kase);
            continue;
        }
        sort(node,node+tot);
        node[tot].x=n;node[tot].y=m;
        for(int i=0;i<=tot;++i){
            x=node[i].x-1,y=node[i].y-1;
            LL a=(x+y)/3;
            LL b=(abs(x-a)+abs(y-2*a))/2;
            dp[i]=Lucas(a,b);
            for(int j=0;j<i;++j){
                if(2*(node[j].y-node[i].y)>node[j].x-node[i].x) continue;
                if(node[j].y-node[i].y<2*(node[j].x-node[i].x)) continue;
                x=node[i].x-node[j].x,y=node[i].y-node[j].y;
                a=(x+y)/3;
                b=(abs(x-a)+abs(y-2*a))/2;
                dp[i]-=(Lucas(a,b)*dp[j])%MOD;
                while(dp[i]<0) dp[i]+=MOD;
            }
        }
        printf("Case #%d: %I64d\n",++kase,dp[tot]);
    }
    return 0;
}

其他：

这题看了看就有容斥的想法，但因为平时自己接触的容斥题实在是太少了，所以多校的确是一个锻炼的好机会啊。

同时，多校第一场的Rigid Frameworks，也是用到了容斥思想，而且也和这题有点类似，不断依靠之前的状态来更新自己的状态。自己写过这题： http://blog.csdn.net/dpppbr/article/details/51972196

还有多校第似场的Lucky7，用状压进行容斥，因为此题中，每个p值a值并没有关联性，所以只能用暴力枚举的方法来计算答案，如果容斥之间的各点有关系的话，计算量就可以简化很多。