[bzoj1227]虔诚的墓主人

题目描述

小W 是一片新造公墓的管理人。公墓可以看成一块N×M 的矩形，矩形的每个格点，要么种着一棵常青树，要么是一块还没有归属的墓地。当地的居民都是非常虔诚的基督徒，他们愿意提前为自己找一块合适墓地。为了体现自己对主的真诚，他们希望自己的墓地拥有着较高的虔诚度。一块墓地的虔诚度是指以这块墓地为中心的十字架的数目。一个十字架可以看成中间是墓地，墓地的正上、正下、正左、正右都有恰好k 棵常青树。小W 希望知道他所管理的这片公墓中所有墓地的虔诚度总和是多少

输入格式

第一行包含两个用空格分隔的正整数N 和M，表示公墓的宽和长，因此这个矩形公墓共有(N+1) ×(M+1)个格点，左下角的坐标为(0, 0)，右上角的坐标为(N, M)。第二行包含一个正整数W，表示公墓中常青树的个数。第三行起共W 行，每行包含两个用空格分隔的非负整数xi和yi，表示一棵常青树的坐标。输入保证没有两棵常青树拥有相同的坐标。最后一行包含一个正整数k，意义如题目所示。

输出格式

包含一个非负整数，表示这片公墓中所有墓地的虔诚度总和。为了方便起见，答案对2,147,483,648 取模。

样例

样例输入

5 6
13
0 2
0 3
1 2
1 3
2 0
2 1
2 4
2 5
2 6
3 2
3 3
4 3
5 2
2

样例输出

6

数据范围与提示

图中，以墓地(2, 2)和(2, 3)为中心的十字架各有3个，即它们的虔诚度均为3。其他墓地的虔诚度为0。 所有数据满足1 ≤ N, M ≤ 1,000,000,000，0 ≤ xi ≤ N，0 ≤ yi ≤ M，1 ≤ W ≤ 100,000， 1 ≤ k ≤ 10。存在50%的数据，满足1 ≤ k ≤ 2。存在25%的数据，满足1 ≤ W ≤ 10000。 注意：”恰好有k颗树“，这里的恰好不是有且只有，而是从>=k的树中恰好选k棵

 

25%算法：

要求选法，k<=10 杨辉三角打组合数表

n m很大，但w较小，稀疏图。由于k>=1所以无树的坐标直线无贡献，直接离散化，这样得到了最坏情况为w*w的图。然后脑残O(w^2)算一波前缀和，放到四个w^2数组里，再O(w^2)直接扫算贡献。。。

局限：空间复杂度太高O(5w^2)最多卡10000，时间O(w^2)

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
//#define MAXN 1000005
#define MAXK 11
#define MAXW 10005
#define ll long long
#define reg register
#define F(i,a,b) for(i=a;i<=b;++i)
using namespace std;
//对图离散化，因为k>=1，所以在某坐标直线上无树则无贡献
ll c[MAXW][MAXK];
ll mod=2147483647;
int H[MAXW],L[MAXW],e[MAXW][MAXW],hs[MAXW][MAXW],ls[MAXW][MAXW],la[105][105],n,m,cx,cy;
int read()
{
    reg char c; reg int x=0;
    c=getchar();
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9') x=x*10+c-48,c=getchar();
    return x;
}
struct POINT{
    int x,y;
}p[MAXW];
void debug()
{
    reg int i,j;
    F(i,0,n)
    {
        F(j,0,m)
        {
            printf("%d ",la[i][j]);
        }
        puts("");
    }
    puts("");
    F(i,1,cx)
    {
        F(j,1,cy)
        {
            printf("%d ",hs[i][j]);
        }
        puts("");
    }
    puts("");
    F(i,1,cx)
    {
        F(j,1,cy)
         {
             printf("%d ",ls[i][j]);
        }
        puts("");
    }
}
int main()
{
    int W,u; reg int i,j;
    mod++;
    n=read(); m=read(); W=read();
    F(i,1,W) 
        p[i].x=H[i]=read(),p[i].y=L[i]=read();
    sort(H+1,H+W+1);            sort(L+1,L+W+1);
    cx=unique(H+1,H+W+1)-H-1;     cy=unique(L+1,L+W+1)-L-1;
    F(i,1,W)
    {
//        la[p[i].x][p[i].y]=1;
        p[i].x=lower_bound(H+1,H+cx+1,p[i].x)-H;
        p[i].y=lower_bound(L+1,L+cy+1,p[i].y)-L;
         e[p[i].x][p[i].y]=1;
    }
    u=read();
    c[0][0]=1;
    F(i,1,n)
    {
        c[i][0]=1;
        F(j,1,min(i,u)) c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
    }
    F(i,1,cx)
    {
        F(j,1,cy)
        {
            hs[i][j]=hs[i][j-1]+e[i][j];
            ls[i][j]=ls[i-1][j]+e[i][j];
        }
    }
    reg int w,a,s,d;
    reg ll ans=0;
    F(i,1,cx)
    {
        F(j,1,cy)
        {
            if(e[i][j]) continue;
            w=hs[i][j]; a=ls[i][j]; s=ls[cx][j]-ls[i][j]; d=hs[i][cy]-hs[i][j];
            if(w<u||a<u||s<u||d<u) continue;
//            printf("%d %d %d %d %d %d\n",i,j,w,a,s,d);
//            printf("    %lld %lld %lld %lld\n",c[w][u],c[a][u],c[s][u],c[d][u]);
            ans=(ans+c[w][u]*c[a][u]%mod*c[s][u]%mod*c[d][u]%mod)%mod;
        }
    }
//    printf("%lld",c[4][2]);
//    debug();
    printf("%lld",ans);
    return 0;
}

 

60%算法：

针对于上面的局限，考虑把平面问题转化为线性，优化aa[]...的预处理。

首先在离散化时顺带处理出每行每列的总树数 hs[] ls[]，然后对所有树以x为第一关键字，y为第二关键字排序，这样O(w)扫描满足拓扑序直接统计即可。

然后再O(w)扫，知有贡献的墓地一定在同一行且两侧常青树>=k的段(但不一定满足列)中，每段的贡献为Σ(c[j上][k]*c[j下][k])*c[j左][k]*c[j右][k]，j在同一行的两棵常青树中。

局限：时间复杂度(w^2)

 

100%算法：

不难发现上面的柿子可以用前缀和优化，由于带修用树状数组。

树状数组维护前i列的Σ(c[j上][k]*c[j下][k])，每扫到树更新当前列即可。由此复杂度优化到O(wlogw)。

常数黑科技优化，对2^32取模，可以用unsigned int对2^64自然溢出，最后输出再%2^32。

WA因：

if(ww[i]>=u&&ss[i]-1>=u)
        {
            add(p[i].y,-wl[p[i].y]);
            add(p[i].y,c[ww[i]][u]*c[ss[i]-1][u]);
            wl[p[i].y]=c[ww[i]][u]*c[ss[i]-1][u];
        }

若此树是该列的第一棵不能做出贡献的树，则未将其列贡献清零。

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define MAXK 11
#define MAXW 100005
#define un unsigned
#define ll long long
#define reg register
#define F(i,a,b) for(i=a;i<=b;++i)
using namespace std;
un int c[MAXW][MAXK],tr[MAXW];
ll mod=2147483647;
int H[MAXW],L[MAXW],hs[MAXW],ls[MAXW],n,m,cx,cy,ww[MAXW],aa[MAXW],ss[MAXW],dd[MAXW],htot[MAXW],ltot[MAXW],W;
un int wl[MAXW];
int read()
{
    reg char c; reg int x=0;
    c=getchar();
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9') x=x*10+c-48,c=getchar();
    return x;
}
struct POINT{
    int x,y;
    friend bool operator<(POINT a,POINT b)
    {
        return a.x==b.x?a.y<b.y:a.x<b.x;
    }
}p[MAXW];
void add(int x,un int w)
{
    while(x<=W)
    {
        tr[x]+=w;
        x+=(x&-x);
    }
}
un int get(int x)
{
    reg un int ans=0;
    while(x>0)
    {
        ans+=tr[x];
        x-=(x&-x);
    }
    return ans;
}
int main()
{
    int u; reg int i,j;
    mod++;
    n=read(); m=read(); W=read();
    F(i,1,W) p[i].x=H[i]=read(),p[i].y=L[i]=read();
    sort(H+1,H+W+1);            sort(L+1,L+W+1);
    cx=unique(H+1,H+W+1)-H-1;     cy=unique(L+1,L+W+1)-L-1;
    F(i,1,W)
    {
        p[i].x=lower_bound(H+1,H+cx+1,p[i].x)-H;
        p[i].y=lower_bound(L+1,L+cy+1,p[i].y)-L;
         ++htot[p[i].x];
        ++ltot[p[i].y];
    }
    u=read();
    sort(p+1,p+W+1);
    c[0][0]=1;
    F(i,1,W)
    {
        c[i][0]=1;
        F(j,1,min(i,u)) c[i][j]=c[i-1][j]+c[i-1][j-1];
    }
    F(i,1,W)
    {
        ss[i]=ltot[p[i].y]-ls[p[i].y];
        dd[i]=htot[p[i].x]-hs[p[i].x];
        ww[i]=++ls[p[i].y];
        aa[i]=++hs[p[i].x];
    }
    reg un int ans=0;
    F(i,1,W)
    {
        add(p[i].y,-wl[p[i].y]);
        add(p[i].y,c[ww[i]][u]*c[ss[i]-1][u]);
        wl[p[i].y]=c[ww[i]][u]*c[ss[i]-1][u];
        if(p[i-1].x==p[i].x&&aa[i]-1>=u&&dd[i]>=u)
            ans+=(get(p[i].y-1)-get(p[i-1].y))*c[aa[i]-1][u]*c[dd[i]][u];
    }
    printf("%lld",ans%mod);
    return 0;
}

PS：第一次对拍 存板

#include<cstdio>
#include<algorithm>
#include<ctime>
#include<cstring>
//#define MAXN 1000005
#define MAXK 11
#define MAXW 100005
#define un unsigned
#define ll long long
#define reg register
#define F(i,a,b) for(i=a;i<=b;++i)
using namespace std;

int main()
{
    reg double t1,t2;
    while(1)
    {
        system("./data.out");
        system("./std.out");
        t1=clock();
        system("./a.out");
        t2=clock();
        if(system("diff std.ans a.ans"))
        {
            printf("WA %lfms\n",(t2-t1));
            return 0;
        }
        else printf("AC %lfms\n",(t2-t1));
    }
    return 0;
}

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<ctime>
#include<cstring>
#define MAXN 30000
#define MAXK 10
#define MAXW 100000
#define un unsigned
#define ll long long
#define reg register
#define F(i,a,b) for(i=a;i<=b;++i)
using namespace std;
bool e[MAXN+5][MAXN+5];
int rad()
{
    return rand()*rand();
}
int main()
{
    freopen("data.in","w",stdout);
    srand(time(NULL));
    int n,m,w,k;
    n=rad()%MAXN+1; m=rad()%MAXN+1; w=rad()%min(MAXW,(n+1)*(m+1))+1; k=rad()%MAXK+1;
    printf("%d %d\n%d\n",n,m,w);
    reg int i,a,b;
    F(i,1,w)
    {
        do{a=rad()%(n+1);b=rad()%(m+1);}while(e[a][b]);
        e[a][b]=1;
        printf("%d %d\n",a,b);
    }
    printf("%d",k);
    return 0;    
}