2016多校合练 1002 【A Simple Chess】题解

最新推荐文章于 2024-10-01 18:52:56 发布

Ivan_wb

最新推荐文章于 2024-10-01 18:52:56 发布

阅读量615

点赞数 1

文章标签：多校合练 ACM 组合数学动态规划

本文链接：https://blog.csdn.net/ivan_wb/article/details/52121736

版权

题意，在一个n*m的棋盘上，只能向右下方向走 ‘日’ ，并且有r个点是坏的，问有多少种走到点 (n,m) 的情况。

读完题以后可以很容易的得到没有障碍物的情况下是这样的：

不难看出这是一个杨辉三角形，如果转过来的话，第i行第j个数（从0开始计算）就是 c ( i , j ) (从i个物品里取j个的组合数);

我们转换一下坐标把图正过来。

斜着的（如上图）的坐标是(x,y)，那么正过来为 ( x' , y' ) ，坐标 x'= (x+y+1) / 3 - 1 , y' = y - x'。

就是如下图：

但是因为题意中表明有些点是不可到达的。

我们假设第5行第2个数4是坏的，那么上图就会变成如下图：

举例来看，最后一行第四个数由原图 35 变成了 23 ，减少了12，那是因为在5*2图的终点是4 , 4*3的图的终点是3，即C(4,1)=4, C(3,2)=3.所以少了 4*3=12 种可能性。

由下图我们可以更清楚的理解：

我们认为0点是起点，A点是不可到达点，B点是终点，f(A)表示由原点到A点的方案数，f(B)就表示从原点到B点的方案数，那么不经过A点到B点的方案数就是f(B)-f(A)*f(B-A)。

但是这样存在一个容斥问题，如下图：

我们认为C是终点，A和B都是不可到达点，那么按照我们的公式计算不经过A点B点的方案数就是

f(C)-f(A)*f(C-A)-f(B)*f(C-B)+f(A)*f(B-A)*f(C-B)

注意最后一定要加上f(A)*f(B-A)*f(C-B)，这表示同时经过A和B点到达C点的方案数，因为在之前减去了经过A点到C点的方案数也减去了经过B点到C点的方案数，重复剪了一次，所以需要加上。

由题意知，最多存在100个障碍点不可到达，那么直接来写公式计算的话，其项数多达2^100项，显然是不可以的。

化简公式，我们令g(X)表示不经过障碍点到达点X的方案数。

那么得到：

g(A)=f(A);

g(B)=f(B)-f(A)*f(B-A), 即 g(B)=f(B)-g(A)*f(B-A);

g(C)=f(C)-f(A)*f(C-A)-f(B)*f(C-B)+f(A)*f(B-A)*f(C-B), 即 g(C)=f(C)-g(A)*f(C-A)-g(B)*f(C-B);

由上述公式：

g(A)=f(A);

g(B)=f(B)-g(A)*f(B-A);

g(C)=f(C)-g(A)*f(C-A)-g(B)*f(C-B);

我们猜想g(X)=f(X)-g(A)*f(X-A)-g(B)*f(X-B)-......;

经检验点D，发现猜想正确。

至此，此题的思路已经全部出炉。

下面就是如何计算f(p),f(p)即求C(p.x,p.y)%MOD使用Lucas定理就解决了。

/*
 * test.cpp
 *
 *  Created on: 2016年8月4日
 *      Author: PC-100
 */
#include <functional>
#include <algorithm>
#include <iostream>
//#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cstring>
#include <stdlib.h>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <ctype.h>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>

const double PI = acos(-1.0);
const double e = exp(1.0);
const double eps=1e-8;

inline int sign(double x){return (x>eps)-(x<-eps);}
template<class T> T gcd(T a, T b) {
    return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {
    return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {
    return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {
    return a > b ? a : b;}
bool cmpbig(int a, int b) {
    return a > b;}
bool cmpsmall(int a, int b) {return a < b;}
using namespace std;
/******************************************************/
#define mem(a) memset(a,0,sizeof(a))
#define pfd(a) printf("%d",a)
#define pf2d(a,b) printf("%d %d",a,b)
#define pf3d(a,b,c) printf("%d %d %d",a,b,c)
#define pf4d(a,b,c,d) printf("%d %d %d %d",a,b,c,d)
#define pfn printf("\n")
#define pfdn(a) printf("%d\n",a)
#define pf2dn(a,b) printf("%d %d\n",a,b)
#define pf3dn(a,b,c) printf("%d %d %d\n",a,b,c)
#define pf4dn(a,b,c,d) printf("%d %d %d %d\n",a,b,c,d)
#define pfsn(a) printf("%s\n",a)
#define sfd(a) scanf("%d",&a)
#define sf2d(a,b) scanf("%d%d",&a,&b)
#define sf3d(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define sf4d(a,b,c,d) scanf("%d%d%d%d",&a,&b,&c,&d)
#define sfs(a) scanf("%s",a)
#define sf    scanf
#define pf    printf
/******************************************************/
#define ll __int64
#define sf64(a)    scanf("%I64d",&a)
#define sf264(a,b)    scanf("%I64d%I64d",&a,&b)
#define sf364(a,b,c)    scanf("%I64d%I64d%I64d",&a,&b,&c)
#define sf464(a,b,c,d)    scanf("%I64d%I64d%I64d%I64d",&a,&b,&c,&d)
#define pf64n(a) printf("%I64d\n",a)
#define pf264n(a,b) printf("%I64d %I64d\n",a,b)
#define pf364n(a,b,c) printf("%I64d %I64d %I64d\n",a,b,c)
#define pf464n(a,b,c,d) printf("%I64d %I64d %I64d %I64d\n",a,b,c,d)
#define pf64(a) printf("%I64d",a)
#define pf264(a,b) printf("%I64d %I64d",a,b)
#define pf364(a,b,c) printf("%I64d %I64d %I64d",a,b,c)
#define pf464(a,b,c,d) printf("%I64d %I64d %I64d %I64d",a,b,c,d)
#define read()    freopen("1.txt","r",stdin);

/******************************************************/

const int dir4[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
const int dir8[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};

#define N 1001000
#define M 1010
#define MOD 110119
#define INF 0x7fffffff

/******************************************************/
ll fac[N];
map<ll,map<ll,ll> > mp;
ll f[110],g[110];

struct ro{
    ll x;
    ll y;
}rr[110];

void init(ll p){//初始化 ，用f数组记录区域后的阶乘
    ll i;
    fac[0] =1;
    for(i =1; i <= p; i++)
        fac[i] = fac[i-1]*i % p;
}

ll exp_mod(ll a, ll b, ll p){//快速幂
    ll tmp = a % p, ans =1;
    while(b){
        if(b & 1)  ans = ans * tmp % p;
        tmp = tmp*tmp % p;
        b >>=1;
    }
    return  ans;
}

ll C(ll n, ll m, ll p)//计算C(n,m)%p
{
    if(m > n)
        return 0;
    return  fac[n]*exp_mod(fac[m]*fac[n-m], p-2, p) % p;//逆元
}

ll Lucas(ll n, ll m, ll p)//运用卢卡斯定理计算C(n,m)%p
{
    if(m ==0)
        return 1;
    return  (C(n%p, m%p, p)*Lucas(n/p, m/p, p))%p;
}

ll get(ll n,ll m){
    if((n+m+1)%3!=0)
        return 0;
    ll x=(n+m+1)/3;
    ll y=m-x+1;
    if(y<=0||y>x)
        return 0;
    return Lucas(x-1,y-1,MOD);
}
bool cmp(ro a,ro b){
    if(a.x==b.x)
        return a.y<b.y;
    else
        return a.x<b.x;
}

int main(){
    ll n,m,r;
    init(MOD);
    int cas=1;
    while(~sf364(n,m,r)){
        mp.clear();
        int num=0;
        for(int i=0;i<r;i++){
            ll x1,y1;
            sf264(x1,y1);
            if(mp[x1][y1]==1)
                continue;
            mp[x1][y1]=1;
            rr[num].x=x1;
            rr[num++].y=y1;
        }
        rr[num].x=n;
        rr[num++].y=m;
        sort(rr,rr+num,cmp);
        for(int i=0;i<num;i++){
            g[i]=get(rr[i].x,rr[i].y);
            for(int j=0;j<i;j++){
                g[i]=((g[i]-g[j]*get(rr[i].x-rr[j].x+1,rr[i].y-rr[j].y+1)%MOD)+MOD)%MOD;
            }
        }
        pf("Case #%d: ",cas++);
        pf64n(g[num-1]%MOD);
    }
    return 0;
}