bzoj 4548: 小奇的糖果 && bzoj 3658: Jabberwocky（双向链表+树状数组）

3658: Jabberwocky

Time Limit: 20 Sec  Memory Limit: 1024 MB
Submit: 263  Solved: 107

[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

将问题简化：

假设线段只有可能在在坐标系的最下面or最上面，并且每个x坐标都不同

那么只要用双向链表O(n)模拟一下就好了，所有坐标点按x大小排序，第p个节点就是从小到大第p个坐标

每个节点p记录一个p.pre和p.next，分别表示在左边or右边颜色相同且离得最近的节点id，

答案就是max(max(p.next-1-p, p-1-p.pre))  (1<=p<=n)，也就是两个相邻的相同颜色节点之间距离的最大值

如果存在x坐标相同的点

要先将x坐标离散化，并且上面的那个式子就会有问题，因为x坐标相同的点只有可能同时取或同时不取

这样就不能直接求p.next和p的间隔了，而是找到x坐标刚好小于p.next点以及x坐标刚好大于p点的两点之间有多少个点，求这个的最大值，因为离散化过了，这个很好处理

p和p.pre之间同理

显然这题线段没有限制，不一定在最下面or最上面

那样的话我们需要按y坐标从小到大排序（如果相同再按x排序）

求出来上面的东西之后再从下到上扫描，逐个删点，每删一个点求一次最大值

因为是双向链表，所以删点是O(1)的，并且只有这段变大的区间会影响答案

不过因为中间有些点已经消失了，所以不能直接通过相减求间隔，要用树状数组保存哪些还没有被删

别忘了还要从上往下再来一次

总复杂度O(n)+O(2nlogn)=O(nlogn)

注意这题有个坑，假设有k种颜色但是下面出现的不同颜色数量都不到k个，那么答案就是n（也就是所有点全部选中）还有bzoj3658这题的数据比较强，虽然是一模一样的题，但一开始我4548AC了，3658WA，不是long long的问题

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define LL long long
typedef struct
{
LL pre;
LL nxt;
}Line;
Line h[100005];
typedef struct Res
{
LL x, y;
LL id;
LL col;
bool operator < (const Res &b) const
{
if(id<b.id)
return 1;
return 0;
}
}Res;
Res s[100005];
LL cnt, Hash[100005], tre[100005], temp[100005], y[100005], col[100005];
bool compx(Res a, Res b)
{
if(a.x<b.x)
return 1;
return 0;
}
bool compy(Res a, Res b)
{
if(a.y<b.y || a.y==b.y && a.x<b.x)
return 1;
return 0;
}
void Update(LL x, LL val)
{
while(x<=cnt)
{
tre[x] += val;
x += x&-x;
}
}
LL Query(LL x)
{
LL sum = 0;
while(x)
{
sum += tre[x];
x -= x&-x;
}
return sum;
}
int main(void)
{
LL T, i, n, m, ans;
scanf("%lld", &T);
while(T--)
{
cnt = 0;
scanf("%lld%lld", &n, &m);
memset(col, 0, sizeof(col));
for(i=1;i<=n;i++)
{
scanf("%lld%lld%lld", &s[i].x, &s[i].y, &s[i].col);
s[i].id = i;
Hash[++cnt] = s[i].x;
col[s[i].col] = 1;
}
for(i=1;i<=m;i++)
{
if(col[i]==0)
break;
}
if(i<=m)
{
printf("%lld\n", n);
continue;
}
sort(Hash+1, Hash+cnt+1);
cnt = unique(Hash+1, Hash+cnt+1)-(Hash+1);
s[n+1].x = cnt+1;
for(i=1;i<=n;i++)
s[i].x = lower_bound(Hash+1, Hash+cnt+1, s[i].x)-Hash;

ans = 0;
sort(s+1, s+n+1, compx);
memset(temp, 0, sizeof(temp));
for(i=1;i<=n;i++)
{
Update(s[i].x, 1);
h[i].pre = temp[s[i].col];
s[i].id = i;
temp[s[i].col] = i;
ans = max(ans, Query(s[i].x-1)-Query(s[h[i].pre].x));
}
for(i=1;i<=n;i++)
temp[i] = n+1;
for(i=n;i>=1;i--)
{
h[i].nxt = temp[s[i].col];
temp[s[i].col] = i;
ans = max(ans, Query(s[h[i].nxt].x-1)-Query(s[i].x));
}
sort(s+1, s+n+1, compy);
for(i=1;i<=n;i++)
y[i] = s[i].id;
sort(s+1, s+n+1);
for(i=1;i<=n;i++)
{
Update(s[y[i]].x, -1);
ans = max(ans, Query(s[h[y[i]].nxt].x-1)-Query(s[h[y[i]].pre].x));
h[h[y[i]].nxt].pre = h[y[i]].pre;
h[h[y[i]].pre].nxt = h[y[i]].nxt;
}

sort(s+1, s+n+1, compx);
memset(temp, 0, sizeof(temp));
for(i=1;i<=n;i++)
{
Update(s[i].x, 1);
h[i].pre = temp[s[i].col];
s[i].id = i;
temp[s[i].col] = i;
ans = max(ans, Query(s[i].x-1)-Query(s[h[i].pre].x));
}
for(i=1;i<=n;i++)
temp[i] = n+1;
for(i=n;i>=1;i--)
{
h[i].nxt = temp[s[i].col];
temp[s[i].col] = i;
ans = max(ans, Query(s[h[i].nxt].x-1)-Query(s[i].x));
}
sort(s+1, s+n+1, compy);
for(i=1;i<=n;i++)
y[i] = s[i].id;
sort(s+1, s+n+1);
for(i=n;i>=1;i--)
{
Update(s[y[i]].x, -1);
ans = max(ans, Query(s[h[y[i]].nxt].x-1)-Query(s[h[y[i]].pre].x));
h[h[y[i]].nxt].pre = h[y[i]].pre;
h[h[y[i]].pre].nxt = h[y[i]].nxt;
}
printf("%lld\n", ans);
}
return 0;
}