HDU 5116 Everlasting L

题目链接：HDU-5116

题意:给定若干个整数点，若一个点集满足P = {(x, y), (x + 1, y), . . . , (x + a, y), (x, y + 1), . . . , (x, y + b)}(a, b ≥ 1)  且 gcd(a, b)==1 则称这是一个好(a, b)-L集。求共有多少个(A, B)满足A，B都是好L集且A，B不相交。

思路是先找出好L集的数量a，再找出相交的好L集对数b，则答案为a * a - b 。

首先要解决的第一个问题是求出a，一个自然的思路是对于每个点，分别向右、向下搜索，但是这样做会超时。所以我们需要优化一下。

首先算出每个点向右、向下最远长度，记为rght[i][j]和down[i][j]。然后对于每个点，在向右搜索时，对于当前搜索到的长度L，我们希望能知道有多少向下的长度D可以与之组成一个好L-集。所以优化的思路就是处理出在[ 1, down[i][j] ]范围内，有多少数与L互质。我们用f[i][j]表示在[0, j]范围内有多少数与i的gcd等于1。

这样我们就解决了第一个问题。

对于第二个问题，我们处理出，对于每一个点(i, j)，有多少好L-集的下路经过点(i, j)，用sum[i][j]表示，那么假设存在x个右路经过点(i, j)的好L-集，则 b += 2 * x * sum[i][j]。

具体请参照代码：

//f[i][j]表示在[1,j]范围内，有多少数与i的gcd=1。
//g[i][j]表示在sum(gcd(a,b)==1) (1<=a<=i && 1<=b<=j)
//rght[i][j]表示点(i, j)右路最长长度
//down[i][j]表示点(i, j)下路最长长度
//sum[i][j]表示下路通过(i, j)的好L-集的个数

#include<cstdio>
#include<set>
#include<map>
#include<cstring>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;
typedef long long LL;

const LL MAXN=210;

LL gcd(LL a,LL b)
{
    if(b==0) return a;
    return gcd(b,a%b);
}
bool vis[MAXN][MAXN];
LL g[MAXN][MAXN],f[MAXN][MAXN],down[MAXN][MAXN],rght[MAXN][MAXN],sum[MAXN][MAXN];
int main()
{
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif
    memset(g,0,sizeof(g));
    memset(f,0,sizeof(f));
    for(LL i=1;i<=200;i++)
        for(LL j=1;j<=200;j++)
        {
            f[i][j]=f[i][j-1]+(gcd(i,j)==1);
            g[i][j]=g[i-1][j]+f[i][j];
        }
    LL T;
    scanf("%lld",&T);
    for(LL tt=1;tt<=T;tt++)
    {
        memset(down,0,sizeof(down));
        memset(rght,0,sizeof(rght));
        memset(vis,0,sizeof(vis));
        memset(sum,0,sizeof(sum));
        LL n;
        scanf("%lld",&n);
        for(LL i=1;i<=n;i++)
        {
            LL x,y;
            scanf("%lld%lld",&x,&y);
            vis[x][y]=1;
        }
        for(LL i=200;i>=1;i--)
            for(LL j=200;j>=1;j--)
                if(vis[i][j])
                {
                    if(vis[i+1][j]) down[i][j]=down[i+1][j]+1;
                    if(vis[i][j+1]) rght[i][j]=rght[i][j+1]+1;
                }
        LL a=0;
        memset(sum,0,sizeof(sum));
        for(LL i=1;i<=200;i++)
            for(LL j=1;j<=200;j++)
                if(vis[i][j])
                {
                    LL cnt[MAXN];
                    memset(cnt,0,sizeof(cnt));
                    for(LL k=1;k<=down[i][j];k++)
                        cnt[k]+=f[k][rght[i][j]];
                    for(LL k=down[i][j]-1;k>=0;k--)
                        cnt[k]+=cnt[k+1];
                    for(LL k=0;k<=down[i][j];k++)
                        sum[i+k][j]+=cnt[k];
                    a+=cnt[0];
                }
        LL b=0;
        for(LL i=1;i<=200;i++)
            for(LL j=1;j<=200;j++)
                if(vis[i][j])
                {
                    LL cnt=0;
                    for(LL k=rght[i][j];k>=0;k--)
                    {
                        cnt+=f[k][down[i][j]];
                        b+=2*cnt*sum[i][j+k];
                    }
                    b-=g[down[i][j]][rght[i][j]]*g[down[i][j]][rght[i][j]];
                }
        printf("Case #%lld: %lld
",tt,a*a-b);
    }
    return 0;
}