码迷,mamicode.com
首页 > 其他好文 > 详细

完美子图(这道题太难了,得写下来要不回头又忘了)

时间:2020-07-11 22:51:55      阅读:80      评论:0      收藏:0      [点我收藏+]

标签:时间   表示   需要   mda   推出   根据   ems   i++   ace   

题目大意:

给你一个n×n的图,向其中放n个点,求其中有几个“完美子图”。

完美子图的定义是:一个m×m的图(1<=m<=n),其中含有m个点,这样的子图叫完美子图。

已知:在原图中每一行每一列都只有一个点。

分析:

1.对于此类“n×n的图中有n个点且每一行每一列只有一个点”的问题,我们一般可以把二维的图拍扁成一维的区间问题,这道题的一维化转化为:m×m图里面有m个点————>l到r的连续区间内,最大列数减去最小列数等于最大行数减最小行数,同时由于区间是连续的,所以转化为最大行数减去最小行数等于r-l+1。

得出的公式为Max[r,l]-Min[r,l]=r-l,在满足这个条件的前提下,可以看作多增了一个完美子图。

why?

我们可以这样想,一个m×m图内有m个点,且满足上面那个同列同行只有一点的条件,那么在l到l+m-1这个区间里面,最大的行数一定是正方形的下边界,最小行数一定是正方形的上边界,l是左边界,l+m-1是右边界,显然可得上面的推论。

处理方法:

我们可以在输入的时候,定义一个a数组,保存每一列上第几行有点,方便之后处理。

2.这道题已经被我们转化到区间问题了,在区间dp没有明显的状态阶段时候,我们可以考虑到用线段树来维护,啊不,线段树的祖宗:分治思想。

(当然这道题肯定用线段树是可以的啊)

分治思想就是把一个大问题分成几个类型相同的递归子问题,在这里我们就可以:

void Fenzhi(int l,int r){
    if(l==r){
        ans++;
        return;
    }
    int mid=l+r>>1;
    Fenzhi(l,mid);Fenzhi(mid+1,r);
}

根据题目条件,我们可以知道,1×1的格子,只要有点就是完美子图,而且正巧我们的图中保证每一列必然存在一个点,所以终止条件如上。

3.这里的分治时候把l,r分为了两个区间,我们无需处理那两个小区间以内的完美子图数量了,因为它是递归子问题,我们需要处理的是区间横跨两个小区间的完美子图们。

例如:l=1,r=5,mid=3。假设1到2,3到4都有一个完美子图,我们在递归处理时候,1,2这个区间就包括在子问题里了,我们需要处理的是3到4的图。

那么如何处理呢?

4.我们定义一些变量:

i:目前处理区间的左端点。

j:目前处理区间的右端点。

Min[x]:x点到mid的区间内的最小值。

Max[x]:x点到mid的区间内的最大值。

对于一段区间(i到j),我们会出现下面四种情况:

1.区间的最大值与最小值都在mid左侧。

      Max

       ↓

l————i————————mid————————j——————r

          ↑        

          Min

如果这个时候Max-Min=j-i;

根据上面的推论我们可以知道,i到j的区间是一个完美子图。

我们该如何表示这种情况呢?

显然为Max[i]-Max[j]==j-i。(因为Max,Min都在mid左侧,即Max=Max[i]; Min=Min[i]);

if(Max[i]-Min[i]==j-i&&Max[i]>Max[j]&&Min[i]<Min[j])ans++;

当然,因为区间[i,j]的Min,Max都在i到mid一侧,所以必须满足上面的那几个条件,可以自己推一下。

2.区间的最大值与最小值都在mid右侧。

这种情况与上一种类似,就不多赘述了。

if(Max[j]-Min[j]==j-i&&Max[j]>Max[i]&&Min[j]<Min[i])ans++;

3.区间最小值在mid左侧,区间最大值在mid右侧

      Min

      ↓

l————i————mid—————j———r

            ↑

            Max

那么根据类似上面的推法,这种状态的满足条件就是Max[j]-Max[i]=j-i;

if(Max[j]-Min[i]==j-i&&Max[j]>Max[i]&&Min[j]>Min[i])ans++;

当然Max在右侧,那么必须保证Max[j]>Max[i],Min也一样。

4.区间最大值在mid左侧,区间最小值在mid右侧。

也是与上一种类似:

if(Max[i]-Min[j]==j-i&&Max[j]<Max[i]&&Min[j]<Min[i])ans++;

分析到这里,代码也就呼之欲出了,附上代码:

#include<bits/stdc++.h>
using namespace std;
const int maxn=50010;
int n,Max[maxn],Min[maxn],a[maxn];
int ans=0,Xiao,Da;
void Fenzhi(int l,int r){
    if(l==r){
        ans++;
        return;
    }
    int mid=l+r>>1;
    Fenzhi(l,mid);Fenzhi(mid+1,r);
    Min[mid]=a[mid];Max[mid]=a[mid];
    Max[mid+1]=a[mid+1];Min[mid+1]=a[mid+1];
    Xiao=a[mid];Da=a[mid];
    for(int i=mid-1;i>=l;i--){
        Min[i]=min(Xiao,a[i]);
        Max[i]=max(Da,a[i]);
        Xiao=min(Xiao,Min[i]);
        Da=max(Da,Max[i]);
    }
    Xiao=a[mid+1];Da=a[mid+1];
    for(int i=mid+2;i<=r;i++){
        Min[i]=min(Xiao,a[i]);
        Max[i]=max(Da,a[i]);
        Da=max(Max[i],Da);
        Xiao=min(Min[i],Xiao);
    }
    for(int i=mid;i>=l;i--){
        for(int j=mid+1;j<=r;j++){
            if(Max[i]-Min[j]==j-i&&Max[j]<Max[i]&&Min[j]<Min[i])ans++;
            if(Max[j]-Min[i]==j-i&&Max[j]>Max[i]&&Min[j]>Min[i])ans++;
            if(Max[i]-Min[i]==j-i&&Max[i]>Max[j]&&Min[i]<Min[j])ans++;
            if(Max[j]-Min[j]==j-i&&Max[j]>Max[i]&&Min[j]<Min[i])ans++;
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
    }
    Fenzhi(1,n);
    printf("%d",ans);
    return 0;
}

这样就完了吗?当然没有。

因为这道题的n是<50000的,所以这种n方效率的肯定是过不了的,至少要优化到nlogn。

想一想我们在哪里可以优化呢。

我们注意到,主要的时间复杂度位于那个“4种情况”的位置,我们枚举每一个左端点,再枚举每一个右端点,导致了n方的效率,我们需要对此加以优化。

1、对于1、2两种情况:

我们枚举每一个左端点i时,根据(Max[i]-Min[i]=j-i),我们可以直接推出j!这样,处理这两种情况的时候的效率就变成了n。

    for(int i=mid;i>=l;i--){
        int j=i+Max[i]-Min[i];
        if(j>mid&&j<=r&&Max[j]<Max[i]&&Min[j]>Min[i])ans++;
    }
    //状态1:枚举左端点
    for(int j=mid+1;j<=r;j++){
        int i=j-Max[j]+Min[j];
        if(i>=l&&i<=mid&&Max[i]<Max[j]&&Min[i]>Min[j])ans++;
    }
    //状态2,枚举右端点

2.对于3、4两种情况:

好麻烦啊啊啊啊好难处理的对于这种情况我们可以(通过意念)找到一个单调性:

例如情况3:

公式变形:(j-i==Max[j]-Min[i]——>j-Max[j]=i-Min[i])

我们从mid到l枚举每一个左端点,我们知道在这个枚举顺序下(假设右端点不变),区间的Min只会变小或不变(这是显然吧!)

好,那么我们假设枚举到了某个i,我们就先固定住它,由它去更新右区间,如果右区间的Min[j]>Min[i]时,j++,同时记录cnt[j-Max[j]]++(当前的状态,后面用到)。直到不满足条件为止。

j向右枚举的时候跟i类似,也是只会变小或不变,那么只要有一个Min[j]<Min[i]这个j后面的点就一定也<Min[i]了。

同时,我们考虑到,左端点在左移时Min值只会变小,那么上一个左端点遍历的右端点们既然Min值都大于上一个左端点了,也一定大于这个新的左端点,这样右端点就不用再从头再遍历了,只要接着之前的右端点继续向后遍历就ok了。(通过这样把效率由n方改成了n)

但是!右端点满足Min值的关系显然还不够,还需要满足一对Max的关系,这样我们再跑一个k,如果某个j值满足Min值的关系但不满足Max值的关系,我们把上面的cnt值再--。

最后每跑完一个i,我们把ans+=cnt[i-Min[i]]。

此时cnt[i-Min[i]]保存的是所有与i-Min[i]相等的j-Max[j]所保存的cnt值,而当这两个相等时候,根据我们一开头对等式的变形,i到j就是一个完美子图了!

    int j=mid+1,k=mid+1;
    //注意这里i-Max[i]可能为负数,所以加上一个n,保证是正数
        for(int i=mid;i>=l;i--){
        while(Min[j]>Min[i]&&j<=r){
            cnt[j-Max[j]+n]++;j++;
        }
        while(Max[k]<Max[i]&&k<j){
            cnt[k-Max[k]+n]--;k++;
        }
        //注意当j跳出循环时,指向的是一个不满足条件的点,这里k更新的是满足Min条件的点,所以k<j
        ans+=cnt[i-Min[i]+n];
    }
    while(k<j){
        cnt[k-Max[k]+n]--;
        k++;
    } 
        //这里需要把cnt清零,方便之后使用,但不能memset,否则超时   

 

完美子图(这道题太难了,得写下来要不回头又忘了)

标签:时间   表示   需要   mda   推出   根据   ems   i++   ace   

原文地址:https://www.cnblogs.com/liu-yi-tong/p/13285503.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!