POJ 1436 Horizontally Visible Segments

最新推荐文章于 2024-03-30 14:44:30 发布

原创最新推荐文章于 2024-03-30 14:44:30 发布 · 609 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线段树

线段树专栏收录该内容

9 篇文章

订阅专栏

本文介绍使用线段树解决一组平行于Y轴的线段间的可见性问题，通过两种不同的实现方法来查找所有两两之间可见的三元组线段数量。详细解释了线段树的构建、查询及更新过程。

题意：

给你8000条平行Y轴且互不相交的线段，若两条线段之间存在一条只与该两条线段相交的水平线段，则称这两条线段相互可见

求有多少个三条线段两两之间能够相互可见

给你一个整数T,表示T组测试数据

给你一个整数n，表示n条线段

下面n行每行三个整数yi，yii，x ，表示一条线段 0 <= yi' < yi'' <= 8 000, 0 <= xi <= 8 000

方法一：

现将线段按x排序，然后用线段树区间更新求当前线段覆盖了前面哪些线段，因为线段树中存的是点，所以我们要将区间倍增

另外，在更新时，应先查询这个区间会有哪些线段与当前线段可见，然后再将该区间更新为线段i

PS: 我以为暴力枚举会超时的。。。没想到最后只花了一秒多。。

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 8005

using namespace std;

struct edge
{
	int yi, yii, x;
	bool operator < (const edge &a)const
	{
		return x< a.x; 
	}
}edge[maxn];

bool g[maxn][maxn];

struct node
{
	int l, r, num;
}a[4*2*maxn];

void Build(int l, int r, int n)
{
	a[n].l= l;
	a[n].r= r;
	a[n].num= 0;
	if(a[n].l== a[n].r)
		return;
	int mid=(a[n].l + a[n].r)>> 1;
	Build(l ,mid, 2*n);
	Build(mid+1, r, 2*n+1);	
}

void Query(int l, int r, int n, int num) //查询区间[L,R]能和线段num相互看见的有哪些线段 
{
	if(a[n].num)
	{
		g[a[n].num][num]= g[num][a[n].num]= true;
		return;
	}
	if(a[n].l== a[n].r)
		return;
	int mid= (a[n].l+ a[n].r)>> 1;
	if(r<= mid)
		Query(l ,r, 2*n, num);
	else if(l> mid)
		Query(l, r, 2*n+1, num);
	else
	{
		Query(l, mid, 2*n, num);
		Query(mid+1, r, 2*n+1, num);
	}		
}

void update(int l, int r, int n, int num)//将区间[L,R]变成线段num 
{
	if(a[n].l==l && a[n].r== r)
	{
		a[n].num= num;
		return;
	}
	if(a[n].num)
	{
		a[2*n+1].num= a[2*n].num= a[n].num;
		a[n].num= 0;
	}
	int mid= (a[n].l+ a[n].r)>> 1;
	if(r<= mid)
		update(l ,r, 2*n, num);
	else if(l> mid)
		update(l, r, 2*n+1, num);
	else
	{
		update(l, mid, 2*n, num);
		update(mid+1, r, 2*n+1, num);
	}
}

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i= 1; i<= n; i++)
			scanf("%d %d %d",&edge[i].yi,&edge[i].yii, &edge[i].x);
		sort(edge+1, edge+n+1);
		Build(0, 16000, 1);
		memset(g, false, sizeof(g));
		for(int i= 1; i<= n; i++)
		{
			Query(2*edge[i].yi, 2*edge[i].yii, 1, i);
			update(2*edge[i].yi, 2*edge[i].yii, 1, i);
		}
		int ans= 0;
		for(int i= 1; 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[i][k] && g[j][k])
							ans++;
				}			
		printf("%d\n",ans);		
	}
	return 0;
}

方法二：

与方法一不同之处在于，先将区间[L,R]更新为线段num，再用区间[L,R]往下查询哪些线段会与之相互可见

PS: 我最开始就是这样写的。。不过某渣实在是太弱，代码写惨了。。

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
#define maxn 8005

struct edge
{
	int yi, yii, x;
	bool operator < (const edge &a)const
	{
		return x < a.x;
	}
}edge[8005];

struct node
{
	int l, r;
	int sz;
}a[4*2*maxn];

bool g[maxn][maxn];

void Build(int l, int r, int n)
{
	a[n].l= l;
	a[n].r= r;
	a[n].sz= 0;
	if(a[n].l== a[n].r)
		return ;
	int mid= (a[n].l + a[n].r)>> 1;	
	Build(l, mid, 2*n);
	Build(mid+1, r, 2*n+1);	
}

void pushdown(int n)
{
	if(a[n].sz)
	{
		a[2*n].sz= a[2*n+1].sz= a[n].sz;
		a[n].sz= 0;
	}
}

void Query(int l, int r, int n, int num)
{
	if(a[n].sz)
	{
		g[a[n].sz][num]= g[num][a[n].sz]= true;
		return;
	}	
	if(a[n].l== a[n].r)
		return;
	int mid= (a[n].l + a[n].r)/2 ;
	if(r<= mid)
		Query(l, r, 2*n, num);
	else if(l> mid)
		Query(l, r, 2*n+1, num);	 
	else
	{
		Query(l, mid, 2*n, num);
		Query(mid+1, r, 2*n+1, num);
	}	
}


void update(int l, int r, int n, int num)
{
	if(a[n].l== l && a[n].r== r)
	{
		if(a[n].sz)
		{
			g[a[n].sz][num]= g[num][a[n].sz]= true;
			a[n].sz= num;
		}
		else
		{
			Query(l, r, n, num);
			a[n].sz= num;
		}
		return;
	}
	pushdown(n);
	int mid= (a[n].l + a[n].r)/2 ;
	if(r<= mid)
		update(l, r, 2*n, num);
	else if(l> mid)
		update(l, r, 2*n+1, num);	 
	else
	{
		update(l, mid, 2*n, num);
		update(mid+1, r, 2*n+1, num);
	}
}

int main()
{
	int T;scanf("%d",&T);
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i= 1; i<= n; i++)
			scanf("%d %d %d", &edge[i].yi, &edge[i].yii, &edge[i].x);
		sort(edge+1, edge+n+1);
		Build(0, 16000, 1);	
		memset(g, false, sizeof(g));
		for(int i= 1; i<= n; i++)
			update(2*edge[i].yi, 2*edge[i].yii, 1, i);
		int ans= 0;
		for(int i= 1; 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[i][k]&& g[j][k])
							ans++;							
		printf("%d\n",ans);		
	}
	return 0;
}