模拟4题解 T3奇袭

T3奇袭

---

题目描述

由于各种原因，桐人现在被困在Under World（以下简称UW）中，而UW马上 要迎来最终的压力测试——魔界入侵。 

唯一一个神一般存在的Administrator被消灭了，靠原本的整合骑士的力量 是远远不够的。所以爱丽丝动员了UW全体人民，与整合骑士一起抗击魔族。

 在UW的驻地可以隐约看见魔族军队的大本营。整合骑士们打算在魔族入侵前 发动一次奇袭，袭击魔族大本营！

 为了降低风险，爱丽丝找到了你，一名优秀斥候，希望你能在奇袭前对魔族 大本营进行侦查，并计算出袭击的难度。 

经过侦查，你绘制出了魔族大本营的地图，然后发现，魔族大本营是一个N ×N的网格图，一共有N支军队驻扎在一些网格中（不会有两只军队驻扎在一起）。 

在大本营中，每有一个k×k(1≤k≤N)的子网格图包含恰好k支军队，我们袭 击的难度就会增加1点。

 现在请你根据绘制出的地图，告诉爱丽丝这次的袭击行动难度有多大。

输入

第一行，一个正整数N，表示网格图的大小以及军队数量。 

接下来N行，每行两个整数,Xi,Yi，表示第i支军队的坐标。

保证每一行和每一列都恰有一只军队,即每一个Xi和每一个Yi都是不一样 的。

输出

一行，一个整数表示袭击的难度。

样例输入

5
1 1
3 2
2 4
5 5
4 3

样例输出

10

提示

【样例解释】
显然，分别以(2,2)和(4,4)为左上,右下顶点的一个子网格图中有3支军队，
这为我们的难度贡献了1点。
类似的子网格图在原图中能找出10个。
【数据范围】
对于30%的数据，N ≤ 100
对于60%的数据，N ≤ 5000
对于100%的数据，N ≤ 50000

---

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define Re register
using namespace std;
int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
const int maxn=50005;
int n,a[maxn],ans;
int lmax[maxn],lmin[maxn],rmax[maxn],rmin[maxn],t[2*maxn];
void work(int l,int r,int mid)
{
    lmax[mid]=lmin[mid]=a[mid];
    rmax[mid+1]=rmin[mid+1]=a[mid+1];
    for(int i=mid-1;i>=l;i--)
    {
        lmax[i]=max(lmax[i+1],a[i]);
        lmin[i]=min(lmin[i+1],a[i]);
    }
    for(int i=mid+2;i<=r;i++)
    {
        rmax[i]=max(rmax[i-1],a[i]);
        rmin[i]=min(rmin[i-1],a[i]);
    }
    //both left
    for(int i=l;i<=mid;i++)
    {
        int j=i+lmax[i]-lmin[i];
        if(j>mid&&j<=r)
            if(lmax[i]>rmax[j]&&lmin[i]<rmin[j])   //由于左右两个区间必定不会有相等的元素，所以不用考虑等号
                ans++;
    }
    //min is on left ,max is on right
    int L=mid+1,R=mid+1;
    while(L<=r&&lmax[l]>rmax[L])
    {
        t[rmax[L]-L+n]--;//走过的路径是不合法的
        L++;                
    }
    while(R<=r&&lmin[l]<rmin[R])
    {
        t[rmax[R]-R+n]++;//走过的路径都是合法的
        R++;                
    }
    for(int i=l;i<=mid;i++)//i从l向mid移动，lmin变大，lmax变小，使得LR能向左移动
    {
        while(L>mid+1&&lmax[i]<rmax[L-1])//当L==mid+1时，退出循环
        {
            L--;
            t[rmax[L]-L+n]++;
        }
        while(R>mid+1&&lmin[i]>rmin[R-1])
        {
            R--;
            t[rmax[R]-R+n]--;
        }
        if(t[lmin[i]-i+n]>0)
            ans+=t[lmin[i]-i+n];
    }
    for(int i=mid+1;i<=r;i++)
        t[rmax[i]-i+n]=0;
}
void divide(int l,int r)
{
    if(l==r)
    {
        ans++;
        return;
    }
    int mid=(l+r)>>1;
    divide(l,mid);
    divide(mid+1,r);
    work(l,r,mid);
    reverse(a+l,a+r+1);
    if(((r-l)%2)==0) mid--;//1 2 3 4 5 交换后 5 4 3 2 1   仍然应该使123在一个区间所以 mid--;
    work(l,r,mid);
    reverse(a+l,a+r+1);
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        int x,y;
        x=read();y=read();
        a[x]=y;
    }
    divide(1,n);
    printf("%d",ans);
}

 这两种实现都正确，实质相同

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define Re register
using namespace std;
int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
const int maxn=50005;
int n,a[maxn],ans;
int lmax[maxn],lmin[maxn],rmax[maxn],rmin[maxn],t[2*maxn];
void work(int l,int r,int mid)
{
    lmax[mid]=lmin[mid]=a[mid];
    rmax[mid+1]=rmin[mid+1]=a[mid+1];
    for(int i=mid-1;i>=l;i--)
    {
        lmax[i]=max(lmax[i+1],a[i]);
        lmin[i]=min(lmin[i+1],a[i]);
    }
    for(int i=mid+2;i<=r;i++)
    {
        rmax[i]=max(rmax[i-1],a[i]);
        rmin[i]=min(rmin[i-1],a[i]);
    }
    //both left
    for(int i=l;i<=mid;i++)
    {
        int j=i+lmax[i]-lmin[i];
        if(j>mid&&j<=r)
            if(lmax[i]>rmax[j]&&lmin[i]<rmin[j])   //由于左右两个区间必定不会有相等的元素，所以不用考虑等号，下面同理
                ans++;
    }
    //min is on left ,max is on right
    int L=mid+1,R=mid+1;
    for(int i=mid;i>=l;i--)//i从mid向l移动，lmin变小，lmax变大，使得LR能向向右移动
    {
        while(L<=r&&lmax[i]>rmax[L])//属于不合法的部分
        {
            t[rmax[L]-L+n]--;
            L++;
        }
        while(R<=r&&lmin[i]<rmin[R])//
        {
            t[rmax[R]-R+n]++;//合法的
            R++;
        }
        if(t[lmin[i]-i+n]>0)
            ans+=t[lmin[i]-i+n];
    }
    for(int i=mid+1;i<=r;i++)
        t[rmax[i]-i+n]=0;
}
void divide(int l,int r)
{
    if(l==r)
    {
        ans++;
        return;
    }
    int mid=(l+r)>>1;
    divide(l,mid);
    divide(mid+1,r);
    work(l,r,mid);
    reverse(a+l,a+r+1);
    if(((r-l)%2)==0) mid--;//1 2 3 4 5 交换后 5 4 3 2 1   仍然应该使123在一个区间所以 mid--;
    work(l,r,mid);
    reverse(a+l,a+r+1);
}
int main()
{
    n=read();
    for(int i=1;i<=n;i++)
    {
        int x,y;
        x=read();y=read();
        a[x]=y;
    }
    divide(1,n);
    printf("%d",ans);
}