BZOJ3658 Jabberwocky

考虑对于向上包含和向下包含分开计算

不包含所有颜色即有一种颜色一定不包含，考虑枚举这个不被包含的颜色，计算向下包含的最大答案

将所有同颜色的点以x为第一关键字y为第二关键字排序，然后枚举右端点，如果一个点在另一个点的右下方，那么左上方的点就没有用了，因为如果以他右边的点为右边界，他上边的点为上边界的话，左边界不可能在他左边。

所以我们维护一个单调栈，加入一个点x的时候把所有y大于等于这个点的弹栈，并计算以栈顶为左边界，上一个被弹出的栈顶为上边界（如果在这一轮还没弹栈则就是最顶端）的矩形内的点数，更新答案，最后把所有点弹栈并更新答案。

矩形内点数拿个主席树维护就好了

因为每个点会入栈和出栈常数次，并且以每个点为左或上边界会计算矩形内点数常数次，所以复杂度是O(n logn)的

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<queue>
#include<map>
#include<bitset>
#include<stack>
#include<vector>
#include<set>
using namespace std;
#define MAXN 100010
#define MAXM 40000010
#define INF 1000000000
#define MOD 1000000007
#define eps 1e-8
char xB[1<<15],*xS=xB,*xT=xB;
#define getc() (xS==xT&&(xT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xT)?0:*xS++)
inline int read()
{
int x=0,f=1;char ch=getc();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
return x*f;
}
struct pt{
    int x;
    int y;
    int c;
};
pt a[MAXN];
int n,m;
int tlsx[MAXN],tlsy[MAXN],tln;
map<int,int>hx,hy;
int N,M;
int rt[MAXN];
int son[MAXM][2],siz[MAXM];
int tot;
pt st[MAXN];
int tp;
bool sd[MAXN];
int cs;
int ans;
bool cmp(pt x,pt y){
    return x.x!=y.x?x.x<y.x:x.y<y.y;
}
bool cmp1(pt x,pt y){
    return x.c!=y.c?x.c<y.c:x.x!=y.x?x.x<y.x:x.y<y.y;
}
bool cmp2(pt x,pt y){
    return x.c!=y.c?x.c<y.c:x.x!=y.x?x.x<y.x:x.y>y.y;
}
void change(int &x,int xx,int y,int z,int p){
    x=++tot;
    memcpy(son[x],son[xx],sizeof(son[x]));
    siz[x]=siz[xx]+1;
    if(y==z){
        return ;
    }
    int mid=y+z>>1;
    if(p<=mid){
        change(son[x][0],son[xx][0],y,mid,p);
    }else{
        change(son[x][1],son[xx][1],mid+1,z,p);
    }
}
int ask(int x,int xx,int y,int z,int l,int r){
    if(l>r){
        return 0;
    }
    if(y==l&&z==r){
        return siz[xx]-siz[x];
    }
    int mid=y+z>>1;
    if(r<=mid){
        return ask(son[x][0],son[xx][0],y,mid,l,r);
    }else if(l>mid){
        return ask(son[x][1],son[xx][1],mid+1,z,l,r);
    }else{
        return ask(son[x][0],son[xx][0],y,mid,l,mid)+ask(son[x][1],son[xx][1],mid+1,z,mid+1,r);
    }
}
int main(){
	//freopen("input2.in","r",stdin);
	//freopen("dui.txt","w",stdout);
	int tmp;
    int i;
    tmp=read();
    while(tmp--){
        tot=tln=0;
        memset(rt,0,sizeof(rt));
        hx.clear();
        hy.clear();
        cs=0;
        N=M=0;
        ans=0;
        memset(sd,0,sizeof(sd));
        n=read();
        m=read();
        for(i=1;i<=n;i++){
            a[i].x=read();
            a[i].y=read();
            a[i].c=read();
            tlsx[++tln]=a[i].x;
            tlsy[tln]=a[i].y;
            if(!sd[a[i].c]){
                sd[a[i].c]=1;
                cs++;
            }
        }
        if(cs!=m){
            printf("%d\n",n);
            continue ;
        }
        sort(tlsx+1,tlsx+tln+1);
        sort(tlsy+1,tlsy+tln+1);
        hx[tlsx[1]]=++N;
        hy[tlsy[1]]=++M;
        for(i=2;i<=n;i++){
            if(tlsx[i]!=tlsx[i-1]){
                hx[tlsx[i]]=++N;
            }
            if(tlsy[i]!=tlsy[i-1]){
                hy[tlsy[i]]=++M;
            }
        }
        for(i=1;i<=n;i++){
            a[i].x=hx[a[i].x];
            a[i].y=hy[a[i].y];
        }
        sort(a+1,a+n+1,cmp);
        int wzh=1;
        for(i=1;i<=N;i++){
            rt[i]=rt[i-1];
            while(a[wzh].x==i&&wzh<=n){
                change(rt[i],rt[i],1,M,a[wzh].y);
                wzh++;
            }
        }
        sort(a+1,a+n+1,cmp1);
        for(i=1;i<=n;i++){
            if(a[i].c!=a[i-1].c&&i!=1){
                st[tp+1].y=M+1;
                while(tp){
                    ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,1,st[tp+1].y-1));
                    tp--;
                }
                ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,1,st[tp+1].y-1));
            }
            st[tp+1].y=M+1;
            while(tp&&st[tp].y>=a[i].y){
                ans=max(ans,ask(rt[st[tp].x],rt[a[i].x-1],1,M,1,st[tp+1].y-1));
                tp--;
            }
            ans=max(ans,ask(rt[st[tp].x],rt[a[i].x-1],1,M,1,st[tp+1].y-1));
            st[++tp]=a[i];
        }
        st[tp+1].y=M+1;
        while(tp){
            ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,1,st[tp+1].y-1));
            tp--;
        }
        ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,1,st[tp+1].y-1));
        sort(a+1,a+n+1,cmp2);
        for(i=1;i<=n;i++){
            if(a[i].c!=a[i-1].c&&i!=1){
                st[tp+1].y=0;
                while(tp){
                    ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,st[tp+1].y+1,M));
                    tp--;
                }
                ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,st[tp+1].y+1,M));
            }
            st[tp+1].y=0;
            while(tp&&st[tp].y<=a[i].y){
                ans=max(ans,ask(rt[st[tp].x],rt[a[i].x-1],1,M,st[tp+1].y+1,M));
                tp--;
            }
            ans=max(ans,ask(rt[st[tp].x],rt[a[i].x-1],1,M,st[tp+1].y+1,M));
            st[++tp]=a[i];
        }
        st[tp+1].y=0;
        while(tp){
            ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,st[tp+1].y+1,M));
            tp--;
        }
        ans=max(ans,ask(rt[st[tp].x],rt[N],1,M,st[tp+1].y+1,M));
        printf("%d\n",ans);
    }
    return 0;
}
 
/*
1
10 3
7 5 3
38 31 3
3 19 1
30 18 1
12 4 1
23 34 2
11 16 2
26 21 3
8 43 3
26 13 3
 
*/