2019暑期牛客多校第三场

B题：Crazy Binary String

这个B题最长01子序列这个就很明显了

我们取0，1中最少的那个数的2倍，这样的话，显然是最优的   这个还是很好做的

但是我们对这个01均衡的串的话我们该怎么操作呢？

一个很naive的想法是这个串有什么性质呢：  0  1 的数量相同  ，那么  0 1就可以相互抵消  ，只要两个对于对应的奇数位和两个对应的偶数位中间的01能互相消掉的话

那么我们可以就可以算贡献，这个的话就随便搞搞就ok了

还有一钟想法是二分长度，然后check，这个是有问题的  比如说  11000011   这个的话8是可以，4是不行的   

关于这个杨例怎么造呢，我也不知道啊？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？

这个也没啥办法，只能靠自己领会了   

下面是代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <bitset>
typedef long long ll;
using namespace std;
const int maxn=(int)(1e5+2000);
int n;
char s[maxn];
int qilen[maxn*2],oulen[maxn*2];
int main(){
    scanf("%d",&n);
    scanf("%s",s+1);
    memset(qilen,-1,sizeof(qilen));
    memset(oulen,-1,sizeof(oulen));
    int cnt0=0,cnt1=0;
    int ans=0;
    oulen[maxn]=0;
    int q=maxn;
    //cout<<q<<endl;
    for(int i=1;i<=n;i++){
        if(s[i]=='0') cnt0++;
        else cnt1++;
        if(s[i]=='0') q--;
        else q++;
       // cout<<q<<endl;
        if(i%2==1){
            if(qilen[q]==-1) qilen[q]=i;
            else{
                ans=max(ans,(i-qilen[q]));
            }
        }else{
            if(oulen[q]==-1) oulen[q]=i;
            else ans=max(ans,i-oulen[q]);
        }
    }
    printf("%d %d
",ans,2*min(cnt0,cnt1));
    return 0;
}

H题：Magic Line

这个题的话我们首先想一下怎么分成两半，一个最简单的想法是排序，排完序之后   

因为是偶数个吗，中点自然就出现了

然后在中间的点把他们分开，具体用一个两个1e9，-1e9的点来分开就ok，这样还是挺好操作的。大概一下子就能搞掉

下面是代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <bitset>
typedef long long ll;
using namespace std;
const int maxn=1100;
const ll Max=(ll)(1e9);
int t,n;
struct point{
    ll xi,yi;
};
point sum[maxn];

bool cmp(point p1,point p2){
    if(p1.xi==p2.xi) return p1.yi<p2.yi;
    else return p1.xi<p2.xi;
}

int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%lld%lld",&sum[i].xi,&sum[i].yi);
        sort(sum+1,sum+n+1,cmp);
        int m=n/2;
        if(sum[m].xi==sum[m+1].xi){
            if((sum[m+1].yi-sum[m].yi)%2==1){
                printf("%lld %lld %lld %lld
",sum[m].xi-1,(ll)(3e8)+sum[m+1].yi,sum[m].xi+1,sum[m].yi-(ll)(3e8));
            }else{
                ll y=(sum[m+1].yi+sum[m].yi)/2;
                printf("%lld %lld %lld %lld
",sum[m].xi-1,(ll)(3e8)+y,sum[m].xi+1,y-(ll)(3e8));
            }
        }else{
            ll y=(sum[m].yi+sum[m+1].yi)/2;
            printf("%lld %lld %lld %lld
",sum[m].xi,y+(ll)(3e8),sum[m+1].xi,y-(ll)(3e8));
        }
    }
    return 0;
}

F题：Planting Trees

这个的话我们怎么搞呢？？？？？

首先我们知道如果我们要得到最大的区间，在根据他给的数据，知道这个东西某种情况下是需要穷举的，这个的话是要靠我们来努力发现的。

我觉得每道acm题目都是一道道模拟题，   他会给你一个条件，然后我们根据这些条件，应用上来，用这些应用上来的东西发现一个一个的性质，最后

根据性质我们得出这个题目的做法，这个是一般的Acm题的做法

首先我们想看一个矩形怎么合格呢，就是这个矩形的最大值-最小值>m

按照一般的想法我们得枚举出矩形的上边界，下边界，左边界，右边界。然后根据这几个边界中的最大值-最小值>m来做这道题，但是这样就会出现一个问题。

我们这样搞虽然可以通过缓存  然后把题目的复杂度变成n^4来做，但是这个n^4的话显然是会超时的，所以面对这样的情况，我们需要更改一下子，我们枚举上下边界后

肯定可以知道每一列中那个对应的每一列的最大值和最小值，然后我们根据这个最大值，最小值来慢慢操作。

一个显然可以确定的一点是我们可以枚举右边界，然后左边届其实会随着右边界慢慢缩小的，其实这样的话我们只需要维护左边届，缩小的那个条件，我们就可以o(n)完成某个上边界和下边界的操作

没错，就是这样子弄的，我们于是可以枚举右边界，右边界不断向右移动，然后维护一个左边的指针，他一共移动n次。然后我们维护一个最大值单调递减的队列，最小值单调递增的队列。每次把当前边界入队

然后我们看一下最大值-最小值能不能满足条件，不能，l++，把不满足条件的出队即可。

注意一点，这道题常数很大，我们不能通过deque来做，否则会t，我们只能用手写的双端队列，并且当我们在做这道题的时候，还得注意一下

我一开始加了个不必要的特判，然后一直死t，最后删掉了特判，一下子就过了。

下面是代码：

#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <bitset>
#include <cstdio>
#include <queue>
typedef long long ll;
using namespace std;
const int maxn=550;
int t,n,m,ans=0;
int num[maxn][maxn];
int mx[maxn],mn[maxn];
int que1[maxn*2],que2[maxn*2];

void solve(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){ mx[j]=0;mn[j]=(int)(1e9+7);}
        for(int j=i;j<=n;j++){
            //  确定 起点，确定终点
            for(int k=1;k<=n;k++){
                mx[k]=max(mx[k],num[j][k]);
                mn[k]=min(mn[k],num[j][k]);
            }
            int l=1;//做边界
            int head1,tail1,head2,tail2; head1=tail1=head2=tail2=1;
            //维护一个最大值的双端队列  维护一个最小值的双端队列
            for(int k=1;k<=n;k++){
                while(head1<tail1&&mx[que1[tail1]]<mx[k]){
                    tail1--;
                }que1[++tail1]=k;
                while(head2<tail2&&mn[que2[tail2]]>mn[k]){
                    //if(i==1&&j==1) cout<<"aakkkkk"<<endl;
                    tail2--;
                } que2[++tail2]=k;

                while(head1<tail1&&head2<tail2&&mx[que1[head1+1]]-mn[que2[head2+1]]>m){
                    l++;
                    while(head1<tail1&&que1[head1+1]<l) head1++;
                    while(head2<tail2&&que2[head2+1]<l) head2++;
                }
                ans=max(ans,(k-l+1)*(j-i+1));
            }
            // cout<<i<<"   "<<j<<"   "<<ans<<endl;
        }
    }
}

int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        ans=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%d",&num[i][j]);
        solve();
        printf("%d
",ans);
    }
    return 0;
}