【BZOJ-4548&3658】小奇的糖果&Jabberwocky 双向链表 + 树状数组

4548: 小奇的糖果

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 103  Solved: 47
[Submit][Status][Discuss]

Description

有 N 个彩色糖果在平面上。小奇想在平面上取一条水平的线段,并拾起它上方或下方的所有糖果。求出最多能够拾

起多少糖果,使得获得的糖果并不包含所有的颜色。

Input

包含多组测试数据,第一行输入一个正整数 T 表示测试数据组数。

接下来 T 组测试数据,对于每组测试数据,第一行输入两个正整数 N、K,分别表示点数和颜色数。

接下来 N 行,每行描述一个点,前两个数 x, y (|x|, |y| ≤ 2^30 - 1) 描述点的位置,最后一个数 z (1 ≤ z ≤

 k) 描述点的颜色。

对于 100% 的数据,N ≤ 100000,K ≤ 100000,T ≤ 3

Output

对于每组数据在一行内输出一个非负整数 ans,表示答案

Sample Input

1
10 3
1 2 3
2 1 1
2 4 2
3 5 3
4 4 2
5 1 2
6 3 1
6 7 1
7 2 3
9 4 2

Sample Output

5

HINT

Source

By Hzwer

3658: Jabberwocky

Time Limit: 20 Sec  Memory Limit: 1024 MB
Submit: 178  Solved: 73
[Submit][Status][Discuss]

Description

平面上有n个点，每个点有k种颜色中的一个。
你可以选择一条水平的线段获得在其上方或其下方的所有点，如图所示：

 

 

请求出你最多能够得到多少点，使得获得的点并不包含所有的颜色。
   

Input

包含多组测试数据，第一行输入一个数T表示测试数据组数。
    接下来T组测试数据，对于每组测试数据，第一行输入两个数n，k，分别表示点的个数和颜色数。
    接下来n行每行描述一个点，前两个数z，y(lxl，lyl≤2^32-1)描述点的位置，最后一个数z(1≤z≤K）描述点的颜色。
   

Output

 对于每组数据输出一行，每行一个数ans，表示答案。

Sample Input

1
10 3
1 2 3
2 1 1
2 4 2
3 5 3
4 4 2
5 1 2
6 3 1
6 7 1
7 2 3
9 4 2

Sample Output

5

HINT

N<=100000，K<=100000，T<=3

Source

 

Solution

思路比较好的题，本来以为可以转化成某种扫描线，但是无果

首先，按y坐标排序，我们假定这条线无限低，这时候答案相当于相邻两个同种颜色的中间的最大点数

然后这条线向上，一次性删除一行

用双向链表维护一个点的前一个和后一个同种颜色的位置

删除的话，把这个点从树状数组和链表中都删除，每次删除，统计一下这个点之前相邻的和之后相邻的答案

然后把y全都赋成相反数，再做一遍即可得到下端的情况

Code

#include<iostream> 
#include<cstdio> 
#include<cstring> 
#include<algorithm> 
#include<cmath> 
using namespace std; 
int read() 
{ 
    int x=0,f=1; char ch=getchar(); 
    while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();} 
    while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();} 
    return x*f; 
} 
#define MAXN 1000010 
int T,N,K,ans; 
struct PointNode{int x,y,c,id;}P[MAXN]; 
int ls[MAXN],tp,top; 
struct lkList{int last,nxt,now;}lk[MAXN]; 
int C[MAXN]; 
struct BIT 
{ 
    int tree[MAXN]; 
    void Init() {memset(tree,0,sizeof(tree));}
    int lowbit(int x) {return x&(-x);} 
    void Add(int pos,int D) 
        { 
            for (int i=pos; i<=top+1; i+=lowbit(i))  
                tree[i]+=D; 
        }    
    int Query(int pos) 
        { 
            int re=0; 
            for (int i=pos; i; i-=lowbit(i)) 
                re+=tree[i]; 
            return re; 
        } 
    int Query(int L,int R) {if (R<L) return 0; else return Query(R)-Query(L-1);} 
}bit; 
bool cmpY(PointNode A,PointNode B) {return A.y<B.y;} 
bool cmpX(PointNode A,PointNode B) {return A.x<B.x;} 
void Solve() 
{ 
    bit.Init();
    memset(C,0,sizeof(C)); 
    sort(P+1,P+N+1,cmpX); lk[N+1].now=top+1;
    for (int i=1; i<=N; i++) bit.Add(P[i].x,1); 
    for (int i=1; i<=N; i++) 
        { 
            P[i].id=i;
            lk[i].last=C[ P[i].c ]; lk[i].nxt=N+1; lk[i].now=P[i].x; 
            if (C[ P[i].c ]) lk[ C[ P[i].c ] ].nxt=i; 
            C[ P[i].c ]=i;  
            ans=max(ans,bit.Query(P[ lk[i].last ].x+1,P[i].x-1)); 
        } 
//  printf("Ans1=%d\n",ans); 
    sort(P+1,P+N+1,cmpY); 
    for (int i=1; i<=K; i++)  
        ans=max(ans,bit.Query(lk[ C[i] ].now+1,top+1)); 
//  printf("Ans2=%d\n",ans); 
    for (int t=1,i=1; i<=N; i++) 
        { 
            int now=P[i].id; 
            while (t<=N && P[t].y==P[i].y) 
                bit.Add(P[t].x,-1),t++; 
            if (lk[now].nxt) lk[ lk[now].nxt ].last=lk[now].last; 
            if (lk[now].last) lk[ lk[now].last ].nxt=lk[now].nxt; 
            ans=max(ans,bit.Query(lk[ lk[now].last ].now+1,lk[ lk[now].nxt ].now-1)); 
            lk[now].nxt=lk[now].last=0;
        } 
//  printf("Ans3=%d\n",ans); 
} 
int main() 
{ 
    T=read(); 
    while (T--) 
        { 
            N=read(),K=read(); 
            ans=0; 
            for (int i=1; i<=N; i++)  
                ls[++tp]=P[i].x=read(),P[i].y=read(),P[i].c=read(),P[i].id=i; 
            sort(ls+1,ls+tp+1); 
            top=unique(ls+1,ls+tp+1)-ls-1;
            for (int i=1; i<=N; i++) P[i].x=lower_bound(ls+1,ls+top+1,P[i].x)-ls; 
            //for (int i=1; i<=N; i++) printf("x=%d\n",P[i].x); 
            Solve(); 
            for (int i=1; i<=N; i++) P[i].y=-P[i].y; 
            Solve(); 
            printf("%d\n",ans); 
        } 
    return 0; 
}