UVALive 6916 Punching Robot 组合数学

题意：

给了你一个n*m的地图

上面有k个守卫 守卫周围的8个格子是不能经过的

我们只能向右走或者向下走

问你从左上角到右下角有多少种走法

思路：

首先 我们对于一个没有守卫的n*m的地图

从左上角到右下角的走法是C(n+m,n)

因为我们从左上角走到右下角一共需要n+m步 

我们在每一个格子都可以向下或者向右

所以我们需要选择其中的n步向右走 其他m步向下走

如果这个格子有守卫 那么我们经过这个格子的走法就都不行了

但是如果我们一个一个算的话 会有很多条路算重复

就像图中的这条路径就被我们删掉了两次 实际情况可能更多

所以我们先对守卫的坐标去重排序

排完序之后 我们在计算某一个坐标的时候 就要去掉之前计算过的答案

 

ans的含义是到达当前点的可行解是多少 一直算到最后就好了

一开始用的预处理Cmn 但是mod太小 mod以后的逆元处理不出来了

所以只能用费马小定理处理逆元了……

#include<bits/stdc++.h>
#define cl(a,b) memset(a,b,sizeof(a))
#define debug(a) cerr<<#a<<"=="<<a<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

const int maxn=2e6+10;
const int mod=997;

ll fac[maxn],f[maxn];

int dx[10]={0,0,0,1,-1,1,-1,-1,1};
int dy[10]={0,1,-1,0,0,1,-1,1,-1};

ll quick_pow(ll a,ll n)
{
    ll ans=1;
    while(n)
    {
        if(n%2) ans=1ll*ans*a%mod;
        a=1ll*a*a%mod;
        n>>=1;
    }
    return ans;
}

ll inv(ll a)
{
    return quick_pow(a,mod-2);
}

void init()
{
    fac[0]=1;
    for(int i=1;i<maxn;i++)
    {
        fac[i]=1ll*fac[i-1]*i%mod;
    }
}

ll C(ll a,ll b)
{
    ll ans=1;
    if(a<b || b<0) return 0;
    while(a&&b)
    {
        ll aa=a%mod,bb=b%mod;
        if(aa<bb) return 0;;
        ans = 1ll*ans*fac[aa]%mod * inv(1ll*fac[bb]*fac[aa-bb]%mod)%mod;
        a/=mod,b/=mod;
    }
    return ans;
}

template<typename T>
void print(T vec) //打印
{
    for(auto it:vec)
    {
        cout<<it.first<<" "<<it.second<<endl;
    }
}

template<typename T> void solve(T &vec)
{
    sort(vec.begin(),vec.end()); //排序
    auto over=unique(vec.begin(),vec.end()); //去重
    vec.erase(over,vec.end());
}

int main()
{
    int T,cas=1;
    scanf("%d",&T);
    init();
    while(T--)
    {
        vector<pii>st;
        st.clear();
        int n,m,k;
        scanf("%d%d%d",&n,&m,&k);
        n--,m--;
        st.push_back({n,m});
        int x,y,nx,ny;
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            x--,y--;
            for(int j=0;j<9;j++)
            {
                if(x+dx[j]<=n&&y+dy[j]<=m)
                {
                    st.push_back({x+dx[j],y+dy[j]});
                }
            }
        }
        solve(st);
        vector<ll>ans(st.size(),0);
        for(int i=0;i<st.size();i++)
        {
            x=st[i].first;
            y=st[i].second;
            ans[i]=C(x+y,x);
            for(int j=0;j<i;j++)
            {
                nx=st[j].first;
                ny=st[j].second;
                ans[i]=((ans[i]-(ans[j]*C(x+y-nx-ny,x-nx)))%mod+mod)%mod;
            }
        }
        printf("Case #%d: %lld
",cas++,*ans.rbegin());
    }
    return 0;
}/*

5
4 10 2
3 3
2 8
3 5 1
2 3
5 5 0
10 9 3
9 3
6 8
3 4
100000 100000 1
50000 50000

*/