Horizontally Visible Segments
Time Limit: 5000MS | Memory Limit: 65536K |
Description
There is a number of disjoint vertical line segments in the plane. We say that two segments are horizontally visible if they can be connected by a horizontal line segment that does not have any common points with other vertical segments. Three different vertical segments are said to form a triangle of segments if each two of them are horizontally visible. How many triangles can be found in a given set of vertical segments?
Task
Write a program which for each data set:
reads the description of a set of vertical segments,
computes the number of triangles in this set,
writes the result.
Task
Write a program which for each data set:
reads the description of a set of vertical segments,
computes the number of triangles in this set,
writes the result.
Input
The first line of the input contains exactly one positive integer d equal to the number of data sets, 1 <= d <= 20. The data sets follow.
The first line of each data set contains exactly one integer n, 1 <= n <= 8 000, equal to the number of vertical line segments.
Each of the following n lines consists of exactly 3 nonnegative integers separated by single spaces:
yi', yi'', xi - y-coordinate of the beginning of a segment, y-coordinate of its end and its x-coordinate, respectively. The coordinates satisfy 0 <= yi' < yi'' <= 8 000, 0 <= xi <= 8 000. The segments are disjoint.
The first line of each data set contains exactly one integer n, 1 <= n <= 8 000, equal to the number of vertical line segments.
Each of the following n lines consists of exactly 3 nonnegative integers separated by single spaces:
yi', yi'', xi - y-coordinate of the beginning of a segment, y-coordinate of its end and its x-coordinate, respectively. The coordinates satisfy 0 <= yi' < yi'' <= 8 000, 0 <= xi <= 8 000. The segments are disjoint.
Output
The output should consist of exactly d lines, one line for each data set. Line i should contain exactly one integer equal to the number of triangles in the i-th data set.
Sample Input
1 5 0 4 4 0 3 1 3 4 2 0 2 2 0 2 3
Sample Output
1
————————————————————集训27.1的分割线————————————————————
思路:之前没有写查询操作,只写了一个更新操作,无情地TLE了。更新是这样进行的——首先是一旦区间有颜色,建立边,然后下放标记。如果在有效区间内,则更换懒惰标记。但是这个时候并不能return。因为有可能区间的颜色非常散,最坏是一个叶结点有一个颜色。而父结点因为下放懒惰标记失去了颜色。每次必须更新到叶结点为止。
所以懒惰标记的作用丧失了。
应该把查询和更新操作分开进行。
查询:一旦有颜色,说明该区间全部都是该颜色,不论是不是有效区间,因为和有效区间一定有交集,所以直接建立边就可以return了。如果最坏情况,还是要走到叶结点为止。
更新:一旦到了有效区间,直接成段替换,return。否则下放懒惰标记。
代码如下:
/*
ID: j.sure.1
PROG:
LANG: C++
*/
/****************************************/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <climits>
#include <iostream>
#define INF 0x3f3f3f3f
using namespace std;
/****************************************/
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define mid int m = (l+r)>>1
const int N = 8005, maxn = 8005*2;
struct Node
{
int y1, y2, x;
}edge[N];
int col[maxn<<2];
bool G[N][N];
bool cmp(Node a, Node b)
{
return a.x < b.x;
}
void Down(int rt)
{
if(col[rt] != -1) {
col[rt<<1] = col[rt<<1|1] = col[rt];
col[rt] = -1;
}
}
void query(int L, int R, int id, int l, int r, int rt)
{
if(col[rt] != -1) {
if(!G[id][col[rt]]) {
G[col[rt]][id] = G[id][col[rt]] = 1;
}
return ;
}
if(l == r) return ;
mid;
if(L <= m) query(L, R, id, lson);
if(m < R) query(L, R, id, rson);
}
void update(int L, int R, int id, int l, int r, int rt)
{
if(L <= l && r <= R) {
col[rt] = id;
return ;
}
Down(rt);
mid;
if(L <= m) update(L, R, id, lson);
if(m < R) update(L, R, id, rson);
}
int main()
{
#ifdef J_Sure
// freopen("000.in", "r", stdin);
// freopen(".out", "w", stdout);
#endif
int T;
scanf("%d", &T);
while(T--) {
int n;
scanf("%d", &n);
int y1, y2;
for(int i = 0; i < n; i++) {
scanf("%d%d%d", &y1, &y2, &edge[i].x);
edge[i].y1 = y1<<1; edge[i].y2 = y2<<1;
for(int j = 0; j < n; j++) G[i][j] = false;
}
sort(edge, edge+n, cmp);
memset(col, -1, sizeof(col));
for(int i = 0; i < n; i++) {
query(edge[i].y1, edge[i].y2, i, 0, maxn, 1);
update(edge[i].y1, edge[i].y2, i, 0, maxn, 1);
}
int ans = 0;
for(int i = 0; i < n; i++) {
for(int j = i+1; j < n; j++) if(G[i][j]) {
for(int k = j+1; k < n; k++) {
if(G[j][k] && G[i][k]) {
ans ++;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}