POJ 2528 解题报告

于 2014-11-25 13:31:04 发布
阅读量476 收藏
点赞数
分类专栏： POJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thestoryofsnow/article/details/41480089
版权

这道题一开始没想清楚做法，后面突然想通后又感觉很自然。

首先是离散化。由于区间端点的范围太大，所以需要“离散化”，亦即把所有出现的端点排个序，按照他们出现的位置重新编号，这样每个端点的值改成了其大小位置编号，范围瞬间减少了非常多，差不多成了输入的线段数两倍。这时应该可以按照最naive的做法，即把这个范围内的数标记，看覆盖没有做出回答了。但我自己没这么尝试过。

其次是问题的题意理解。比如1 4值得是占据了第一个到第四个区间。再比如有个输入段是5 10那么他们就覆盖了1 10段，因为确实所有的区间都被覆盖了。如果第二个输入段是6 10,那么就不能覆盖1 10段了。这样离散化的时候需要注意：可以把1, 4, 5, 10离散化成0, 1, 2, 3但是不能把1, 4, 6, 10也离散化成0, 1, 2, 3，不然后者会导致错误判断。一个离散化的方法是如果和前面的值连续的，就加1，否则，像6出现在4后面，这样的值离散化成加2。具体见代码实现或者里面给出的链接。看discuss，另一个方法是直接对右端点加1。

然后是线段树的update和query，其实比较难弄清楚，我也是在测试样例的基础上面不断改的。

下面的测试样例：

8
3
5 6
4 5
6 8
3
1 10
1 3
6 10
3
1 10
1 3
6 10
4
2 4
3 5
1 3
5 7
5
1 11
11 11
5 66
7 88
8 110
5
1 4
2 6
8 10
3 4
7 10
5
1 4
2 6
8 10
3 4
7 10
11
1 8
4 6
5 8
2 3
1 5
2 5
6 8
1 3
2 5
4 5
3 4

输出应该是：

2
3
3
3
4
4
4
5

刚开始用的“延迟”update，后面发现根本不需要，如果一个段需要更新，找到合适的区间后就不用向下更新到叶子节点了，因为查找的时候发现这段已经被covered了，也就不用往下看是不是covered了。

2528Accepted1504K63MSG++4981B
/* 
ID: thestor1 
LANG: C++ 
TASK: poj2528 
*/
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <cassert>

using namespace std;

const int MAXN = 25000;

class Poster{
public:
	int left, right;
	Poster() {}
	Poster(int left, int right) : left(left), right(right) {}
};

class Position
{
public:
	int posterid, pos;
	bool isleft;
	Position() {}
	Position(int posterid, int pos, bool isleft) : posterid(posterid), pos(pos), isleft(isleft) {}

	bool operator< (const Position &rhs) const
	{
		if (this->pos != rhs.pos)
		{
			return this->pos < rhs.pos;
		}
		return this->posterid < rhs.posterid;
	}
};

// class Segment
// {
// public:
// 	bool covered, delay;
// 	Segment() : covered(false), delay(false) {}
// 	Segment(bool covered, bool delay) : covered(covered), delay(delay) {}
// };

void update(vector<bool> &segmentTree, int left, int right, int index, const int lindex, const int rindex)
{
	if (segmentTree[index])
	{
		return;
	}

	if (lindex <= left && right <= rindex)
	{
		segmentTree[index] = true;
		return;
	}

	if (left != right)
	{
		int mid = left + ((right - left) >> 1);
		if (rindex <= mid)
		{
			update(segmentTree, left, mid, 2 * index + 1, lindex, rindex);	
		}
		else if (mid + 1 <= lindex)
		{
			update(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);	
		}
		else
		{
			update(segmentTree, left, mid, 2 * index + 1, lindex, rindex);
			update(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);
		}
		segmentTree[index] = segmentTree[2 * index + 1] && segmentTree[2 * index + 2];
	}
}

bool querycovered(vector<bool> &segmentTree, int left, int right, int index, const int lindex, const int rindex)
{	
	if (segmentTree[index])
	{
		return true;
	}

	if (lindex <= left && right <= rindex)
	{
		return segmentTree[index];
	}

	if (left != right)
	{
		int mid = left + ((right - left) >> 1);
		if (rindex <= mid)
		{
			return querycovered(segmentTree, left, mid, 2 * index + 1, lindex, rindex);
		}
		else if (mid + 1 <= lindex)
		{
			return querycovered(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);
		}
		else
		{
			return querycovered(segmentTree, left, mid, 2 * index + 1, lindex, rindex) && querycovered(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);	
		}
	}

	assert (false);
	return false;
}

int main()
{
	// ios::sync_with_stdio(false);
	int T;
	// cin >> T;
	scanf("%d", &T);
	int N;
	vector<Poster> posters(MAXN);
	vector<Position> positions(2 * MAXN);
	vector<bool> segmentTree(9 * MAXN);

	for (int t = 0; t < T; ++t)
	{
		// cin >> N;
		scanf("%d", &N);
		for (int i = 0; i < N; ++i)
		{
			scanf("%d%d", &posters[i].left, &posters[i].right);
			// cin >> posters[i].left >> posters[i].right;
			// positions.push_back(Position(i, posters[i].left, true));
			// positions.push_back(Position(i, posters[i].right, false));
			// positions[2 * i] = Position(i, posters[i].left, true);
			// positions[2 * i + 1] = Position(i, posters[i].right, false);
			positions[2 * i].posterid = i;
			positions[2 * i].pos = posters[i].left;
			positions[2 * i].isleft = true;

			positions[2 * i + 1].posterid = i;
			positions[2 * i + 1].pos = posters[i].right;
			positions[2 * i + 1].isleft = false;
		}

		// compress the coordinates
		sort(positions.begin(), positions.begin() + 2 * N);

		int seqno = 0, before = positions[0].pos, cur;
		for (int i = 0; i < 2 * N; ++i)
		{
			if (positions[i].isleft)
			{
				cur = posters[positions[i].posterid].left;
				// see http://blog.csdn.net/metalseed/article/details/8041334 for reason why
				// basically, for segments like, 1->4, 6->10 and 1->10
				// you want mark that 1->10 is not totally covered by the previous two segments,
				// therefore, you leave space between 4 and 6
				if (cur == before + 1)
				{
					seqno++;
				}
				else if (cur > before + 1)
				{
					seqno += 2;
				}
				posters[positions[i].posterid].left = seqno;
			}
			else
			{
				cur = posters[positions[i].posterid].right;
				if (cur == before + 1)
				{
					seqno++;
				}
				else if (cur > before + 1)
				{
					seqno += 2;
				}

				posters[positions[i].posterid].right = seqno;
			}
			before = cur;
		}

		int size = seqno + 1;
		for (int i = 0; i < 4 * size; ++i)
		{
			segmentTree[i] = false;
		}
		int nvisible = 0;
		for (int i = N - 1; i >= 0; --i)
		{
			if(!querycovered(segmentTree, 0, size - 1, 0, posters[i].left, posters[i].right))
			{
				nvisible++;
				update(segmentTree, 0, size - 1, 0, posters[i].left, posters[i].right);
			}
		}

		printf("%d\n", nvisible);
		// cout << nvisible << endl;
	}
	return 0;  
}



2528Accepted1916K79MSG++5733B

/* 
ID: thestor1 
LANG: C++ 
TASK: poj2528 
*/
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <cassert>

using namespace std;

const int MAXN = 25000;

class Poster{
public:
	int left, right;
	Poster() {}
	Poster(int left, int right) : left(left), right(right) {}
};

class Position
{
public:
	int posterid, pos;
	bool isleft;
	Position() {}
	Position(int posterid, int pos, bool isleft) : posterid(posterid), pos(pos), isleft(isleft) {}

	bool operator< (const Position &rhs) const
	{
		if (this->pos != rhs.pos)
		{
			return this->pos < rhs.pos;
		}
		return this->posterid < rhs.posterid;
	}
};

class Segment
{
public:
	bool covered, delay;
	Segment() : covered(false), delay(false) {}
	Segment(bool covered, bool delay) : covered(covered), delay(delay) {}
};

void update(vector<Segment> &segmentTree, int left, int right, int index, const int lindex, const int rindex)
{
	if (segmentTree[index].covered)
	{
		return;
	}

	if (lindex <= left && right <= rindex)
	{
		segmentTree[index].covered = true;
		if (left != right)
		{
			segmentTree[index].delay = true;
		}
		return;
	}

	if (left != right)
	{
		assert (!segmentTree[index].delay);
		// if (segmentTree[index].delay)
		// {
		// 	segmentTree[2 * index + 1].covered = true;
		// 	segmentTree[2 * index + 1].delay = true;
		// 	segmentTree[2 * index + 2].covered = true;
		// 	segmentTree[2 * index + 2].delay = true;
		// 	segmentTree[index].delay = false;
		// }

		int mid = left + ((right - left) >> 1);
		if (rindex <= mid)
		{
			update(segmentTree, left, mid, 2 * index + 1, lindex, rindex);	
		}
		else if (mid + 1 <= lindex)
		{
			update(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);	
		}
		else
		{
			update(segmentTree, left, mid, 2 * index + 1, lindex, rindex);
			update(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);
		}
		segmentTree[index].covered = segmentTree[2 * index + 1].covered && segmentTree[2 * index + 2].covered;
	}
}

bool querycovered(vector<Segment> &segmentTree, int left, int right, int index, const int lindex, const int rindex)
{	
	if (segmentTree[index].covered)
	{
		return true;
	}

	if (lindex <= left && right <= rindex)
	{
		return segmentTree[index].covered;
	}

	if (left != right)
	{
		if (segmentTree[index].delay)
		{
			segmentTree[2 * index + 1].covered = true;
			segmentTree[2 * index + 1].delay = true;
			segmentTree[2 * index + 2].covered = true;
			segmentTree[2 * index + 2].delay = true;
			segmentTree[index].delay = false;
		}

		int mid = left + ((right - left) >> 1);
		if (rindex <= mid)
		{
			return querycovered(segmentTree, left, mid, 2 * index + 1, lindex, rindex);
		}
		else if (mid + 1 <= lindex)
		{
			return querycovered(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);
		}
		else
		{
			return querycovered(segmentTree, left, mid, 2 * index + 1, lindex, rindex) && querycovered(segmentTree, mid + 1, right, 2 * index + 2, lindex, rindex);	
		}
	}

	assert (false);
	return false;
}

int main()
{
	// ios::sync_with_stdio(false);
	int T;
	// cin >> T;
	scanf("%d", &T);
	int N;
	vector<Poster> posters(MAXN);
	vector<Position> positions(2 * MAXN);
	vector<Segment> segmentTree(9 * MAXN);

	for (int t = 0; t < T; ++t)
	{
		// cin >> N;
		scanf("%d", &N);
		for (int i = 0; i < N; ++i)
		{
			scanf("%d%d", &posters[i].left, &posters[i].right);
			// cin >> posters[i].left >> posters[i].right;
			// positions.push_back(Position(i, posters[i].left, true));
			// positions.push_back(Position(i, posters[i].right, false));
			// positions[2 * i] = Position(i, posters[i].left, true);
			// positions[2 * i + 1] = Position(i, posters[i].right, false);
			positions[2 * i].posterid = i;
			positions[2 * i].pos = posters[i].left;
			positions[2 * i].isleft = true;

			positions[2 * i + 1].posterid = i;
			positions[2 * i + 1].pos = posters[i].right;
			positions[2 * i + 1].isleft = false;
		}

		// compress the coordinates
		sort(positions.begin(), positions.begin() + 2 * N);

		int seqno = 0, before = positions[0].pos, cur;
		for (int i = 0; i < 2 * N; ++i)
		{
			if (positions[i].isleft)
			{
				cur = posters[positions[i].posterid].left;
				// see http://blog.csdn.net/metalseed/article/details/8041334 for reason why
				// basically, for segments like, 1->4, 6->10 and 1->10
				// you want mark that 1->10 is not totally covered by the previous two segments,
				// therefore, you leave space between 4 and 6
				if (cur == before + 1)
				{
					seqno++;
				}
				else if (cur > before + 1)
				{
					seqno += 2;
				}
				posters[positions[i].posterid].left = seqno;
			}
			else
			{
				cur = posters[positions[i].posterid].right;
				if (cur == before + 1)
				{
					seqno++;
				}
				else if (cur > before + 1)
				{
					seqno += 2;
				}

				posters[positions[i].posterid].right = seqno;
			}
			before = cur;
		}

		int size = seqno + 1;
		for (int i = 0; i < 4 * size; ++i)
		{
			segmentTree[i].covered = false;
			segmentTree[i].delay = false;
		}
		int nvisible = 0;
		for (int i = N - 1; i >= 0; --i)
		{
			if(!querycovered(segmentTree, 0, size - 1, 0, posters[i].left, posters[i].right))
			{
				nvisible++;
				update(segmentTree, 0, size - 1, 0, posters[i].left, posters[i].right);
			}
		}

		printf("%d\n", nvisible);
		// cout << nvisible << endl;
	}
	return 0;  
}


thestoryofsnow
关注
专栏目录
B - Mayor's posters
mr_lee
08-07 234
Time Limit: 1000MS   Memory Limit: 65536KB   64bit IO Format: %I64d & %I64u [Submit]   [Go Back]   [Status] Description
POJ 2528 Mayor's posters （线段树区间赋值 + 离散化）
aozil_yang的博客
06-06 454
题意： 给你n 个海报的左端点和右端点  依次贴好后， 求最后能看见几个海报？ 思路: 正常思路想到的是把2n 个端点依次离散化，然后区间赋值，然后查询线段树上每一个区间，最后统计赋值数的种类。 但是这样有个小坑： 例如 1 - 10  1 - 4 6 - 10， 离散化后 区间是 1- 4  1- 2  3 - 4  这样 就把1-4 给覆盖掉了， 就会少数一个海报。 得到2n 个
poj2528
小小小小杜
08-12 644
题目不难，线段树+离散化 大致题意为
poj-2528
fyfcauc的专栏
07-29 517
// 20884K 297MS G++ #include #include #include int posterNum; int ep[20010]; unsigned short dis[10000010]; int epNum; int cmp(const void * p1, const void * p2) { return (*((int*)p1)) - (
POJ 2528
u012896700的专栏
11-27 586
题意：          一块黑板  给你贴广告。。。后面贴的会把前面贴的给覆盖了（如果在同一个地方），         然后最后要你求还有多少广告是能被看到的。。  能被看到任何一点都算能看到。。。    这题难点也在于数据太大。。无法直接用暴力去做。。 所以要用到离散。。。。。     每一个广告有2个端点。他最多有1W个广告。。。也就是说他最多只有2W个端点。 所
poj2828解题报告
12-19
这篇解题报告主要介绍了如何解决POJ2828这个编程题目。该题目涉及的数据结构是区间树（Interval Tree），这是一种用于高效处理区间查询和修改的树形数据结构。在这个问题中，我们需要根据输入的元素位置和值，构建一...
北大poj解题报告
12-23
这个“北大poj解题报告”包含了作者在使用POJ平台解题过程中的学习总结和经验分享，旨在帮助软件工程专业的学生提升编程能力和算法理解。 解题报告通常会涵盖以下几个方面： 1. **基础算法讲解**：解题报告中可能...
poj1691解题报告
12-29
### poj1691解题报告 #### 题目信息 - **题目名称**：Painting A Board - **时间限制**：1S - **内存限制**：1000K - **提交总数**：62 - **通过总数**：35 - **来源**：...
poj 1440解题报告
05-29
poj 1440解题报告 poj 1440解题报告 poj 1440解题报告 poj 1440解题报告
poj 3414解题报告
04-02
poj 3414解题报告poj 3414解题报告poj 3414解题报告poj 3414解题报告
POJ2528
终究我要华丽逆袭
08-25 1331
这道线段树题目应该对我离散化数据的思想有了启蒙，直接做必然超时超内存，所以根据虽然l,r范围好大，但给的海报数n#include #include #include #include using namespace std; mapmp; setst; int cmp(int a,int b) { return a<b; } int a[80010],c[80010],x[10010]
poj 2528
zhangpzh5的专栏
09-19 454
poj2528 Mayor'sposters
poj 2528【线段树-区间更新，区间统计】
lyt9469的专栏
09-20 473
Mayor's posters Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 21505   Accepted: 6176 Description
玛雅历转Tzolkin历：poj1008解题报告
参与POJ平台的解题不仅可以锻炼编程能力，还有助于提高算法和数据结构的应用水平。 2. 编程题目概述： 题目编号为1008的题目要求参赛者编写一个程序来实现玛雅历到Tzolkin历的转换。历法转换在软件开发中属于数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值