HDU 4553：约会安排（区间合并）

最新推荐文章于 2024-05-16 11:43:34 发布

Jaihk662

最新推荐文章于 2024-05-16 11:43:34 发布

阅读量1.2k

点赞数 2

分类专栏： # 高级数据结构文章标签：线段树 kuangbin专题

本文链接：https://blog.csdn.net/Jaihk662/article/details/51779300

版权

高级数据结构专栏收录该内容

48 篇文章 2 订阅

订阅专栏

约会安排

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 1088 Accepted Submission(s): 318

Problem Description

　　寒假来了，又到了小明和女神们约会的季节。
　　小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。
　　我们已知小明一共有T的空闲时间，期间会有很多女神或者基友来找小明。
　　作为一个操作系统曾经怒考71分的大神，小明想到了一个算法，即“首次适应算法”，根据操作系统课本的描述，就是找一段最靠前的符合要求的连续空间分配给每个请求，由此小明做出了一个决定：
　　当一个基友来找小明时，小明就根据“首次适应算法”来找一段空闲的时间来和基友约好，如果找到，就说“X,let’s fly”（此处，X为开始时间），否则就说“fly with yourself”；
　　当女神来找小明时，先使用一次“首次适应算法”，如果没有找到，小明就冒着木叽叽的风险无视所有屌丝基友的约定，再次使用“无视基友首次适应算法”，两次只要有一次找到，就说“X,don’t put my gezi”（此处，X为开始时间），否则就说“wait for me”
　　当然，我们知道小明不是一个节操负无穷的人，如果和女神约会完，还有剩余时间，他还是会和原来约好的基友去dota的。（举个例子：小西（屌丝）和小明约好在1~5这个时间单位段内打dota，这时候，女神来和小明预约长度为3的时间段，那么最终就是1~3小明去和女神约会，搞定后在4~5和小西打dota）
　　小明偶尔也会想要学习新知识，此时小明就会把某一个时间区间的所有已经预定的时间全部清空用来学习并且怒吼“I am the hope of chinese chengxuyuan!!”，不过小明一般都是三分钟热度，再有人来预定的话，小明就会按耐不住寂寞把学习新知识的时间分配出去。

Input

输入第一行为CASE，表示有CASE组测试数据；
每组数据以两个整数T，N开始，T代表总共的时间，N表示预约请求的个数；
接着的N行，每行表示一个女神或者基友的预约，“NS QT”代表一个女神来找小明约一段长为QT的时间，“DS QT”则代表一个屌丝的长为QT的请求，当然也有可能是小明想学知识了，“STUDY!! L R”代表清空L~R区间内的所有请求。

[Technical Specification]
1. 1 <= CASE <= 30
2. 1 <= T, N <= 100000
3. 1 <= QT <= 110000
4. 1 <= L <= R <=T

Output

对于每一个case，第一行先输出“Case C:”代表是第几个case，然后N行，每行对应一个请求的结果(参照描述)。
输出样本(可复制此处)：
“X,let's fly”,”fly with yourself”,”X,don't put my gezi”,”wait for me”,”I am the hope of chinese chengxuyuan!!”

Sample Input

  
  
   
   1
5 6
DS 3
NS 2
NS 4
STUDY!! 1 5
DS 4
NS 2

Sample Output

  
  
   
   Case 1:
1,let's fly
4,don't put my gezi
wait for me
I am the hope of chinese chengxuyuan!!
1,let's fly
1,don't put my gezi

http://acm.hdu.edu.cn/showproblem.php?pid=4553

区间和并：每个节点存有三个值kl，km，kr，值kl表示节点包含最左端端点的连续区间（可能为0），kr表示节点包含最右端端点的连续区间（可能为0），km表示当前节点的最长空闲区间长度，其中每个节点的kl, km, kr值可以由两个子节点对应值算出。

我的思路：将一个时间段分为两个区间，区间A表示和女神约的时间分布，区间B表示有人约的时间分布，若有基友约，直接判断B区间是否还有位置，有就更新B区间，若有女神约，则先判断B区间是否有位置，有就同时更新区间A和B，否则再判断A区间是否有位置，若有还是同时更新区间A和B，如果想要学习，就直接清空区间A和B的对应位置。（三个标记，其中学习的优先级最高，女神基友的优先级其次）

#include<stdio.h>
#include<algorithm>
using namespace std;
typedef struct
{
	int dl, dr, dm;
	int nl, nr, nm;
	int d, n, s;
}Point;
Point tre[444444];
int lie, n;
void Study(int l, int r, int x, int a, int b);
void Query(int l, int r, int x, int s, int t);
void Lazy(int l, int r, int x);
void Atonce(int l, int r, int x);
void Update(int l, int r, int x, int a, int b, int t);
int main(void)
{
	int T, i, m, cas, a, b;
	char str[12];
	scanf("%d", &T);
	cas = 1;
	while(T--)
	{
		scanf("%d%d", &n, &m);
		Study(1, n, 1, 1, n);
		printf("Case %d:\n", cas++);
		for(i=1;i<=m;i++)
		{
			scanf("%s", str);
			if(str[0]=='D')
			{
				scanf("%d", &a);
				if(tre[1].dm<a)				/*如果DS区间位置不够，直接输出*/
					printf("fly with yourself\n");
				else
				{
					Query(1, n, 1, a, 0);
					Update(1, n, 1, lie, lie+a-1, 0);	/*查找合适时间段并更新*/
					printf("%d,let's fly\n", lie);
				}
			}
			if(str[0]=='N')
			{
				scanf("%d", &a);
				if(tre[1].nm<a)			/*如果NS区间位置不够，直接输出*/
					printf("wait for me\n");
				else
				{
					if(tre[1].dm<a)		/*如果DS区间位置不够，查找女神区间（无视所有基友的安排）*/
					{
						Query(1, n, 1, a, 1);
						Update(1, n, 1, lie, lie+a-1, 1);		/*同时更新两个区间，下同*/
						printf("%d,don't put my gezi\n", lie);
					}
					else
					{
						Query(1, n, 1, a, 0);
						Update(1, n, 1, lie, lie+a-1, 1);
						printf("%d,don't put my gezi\n", lie);
					}
				}
			}
			if(str[0]=='S')
			{
				scanf("%d%d", &a, &b);
				Study(1, n, 1, a, b);		/*清空约定*/
				printf("I am the hope of chinese chengxuyuan!!\n");
			}
		}
	}
	return 0;
}
/*
	tre[x].s     ------      学习的标记，为0表示有标记，要更新
	tre[x].n  tre[x].d      ------      女神和基友的标记，为1表示有标记，要更新
*/
void Study(int l, int r, int x, int a, int b)
{
	int m;
	if(l>=a && r<=b)
	{
		if(l!=r)
			tre[x].d = tre[x].n = tre[x].s = 0;		/*延迟标记，注意要清除女神与基友的延迟标记*/
		tre[x].dm = tre[x].dr = tre[x].dl = r-l+1;
		tre[x].nm = tre[x].nr = tre[x].nl = r-l+1;
		return;
	}
	m = (l+r)/2;
	Lazy(l, r, x);
	if(a<=m)
		Study(l, m, x*2, a, b);
	if(b>=m+1)
		Study(m+1, r, x*2+1, a, b);
	Atonce(l, r, x);
}

void Query(int l, int r, int x, int s, int t)		/*查询合适的时间点以进行安排*/
{
	int m;
	m = (l+r)/2;
	Lazy(l, r, x);
	if(t==0)
	{
		if(tre[x*2].dm>=s)		/*如果左节点的最大连续空闲区间要大于和基友玩的时间，则查询左节点*/
			Query(l, m, x*2, s, t);
		else if(tre[x*2].dr+tre[x*2+1].dl>=s)  /*否则如果左节点的右端连续区间和右节点的左端连续区间之和大于和基友玩的时间，则开始时间已确定*/
		{
			lie = m-tre[x*2].dr+1;
			return;
		}
		else
			Query(m+1, r, x*2+1, s, t);		/*上面都不满足，就只能查询右节点*/
	}
	else if(t==1)
	{
		if(tre[x*2].nm>=s)					/*同上*/
			Query(l, m, x*2, s, t);
		else if(tre[x*2].nr+tre[x*2+1].nl>=s)
		{
			lie = m-tre[x*2].nr+1;
			return;
		}
		else
			Query(m+1, r, x*2+1, s, t);
	}
}

void Update(int l, int r, int x, int a, int b, int t)
{
	int m;
	if(l>=a && r<=b)
	{
		if(t==1)
		{
			if(l!=r)
				tre[x].n = 1;
			tre[x].nl = tre[x].nr = tre[x].nm = 0;
		}
		if(l!=r)
			tre[x].d = 1;
		tre[x].dl = tre[x].dr = tre[x].dm = 0;
		return;
	}
	m = (l+r)/2;
	Lazy(l, r, x);
	if(a<=m)
		Update(l, m, x*2, a, b, t);
	if(b>=m+1)
		Update(m+1, r, x*2+1, a, b, t);
	Atonce(l, r, x);
}

void Atonce(int l, int r, int x)
{
	int m;
	m = (l+r)/2;
	tre[x].dl = tre[x*2].dl;
	tre[x].dr = tre[x*2+1].dr;
	if(tre[x*2].dl==m-l+1)
		tre[x].dl += tre[x*2+1].dl;			/*有可能左子节点的整个区间都连续，这时父节点的左端连续区间就等于左子节点区间长度+右子节点的左端连续区间*/
	if(tre[x*2+1].dr==r-m)
		tre[x].dr += tre[x*2].dr;			/*同上*/
	tre[x].dm = max(max(tre[x].dl, tre[x].dr), max(max(tre[x*2].dm, tre[x*2+1].dm), tre[x*2].dr+tre[x*2+1].dl));
						/*计算父节点的最长连续区间*/
	tre[x].nl = tre[x*2].nl;
	tre[x].nr = tre[x*2+1].nr;
	if(tre[x*2].nl==m-l+1)
		tre[x].nl += tre[x*2+1].nl;
	if(tre[x*2+1].nr==r-m)
		tre[x].nr += tre[x*2].nr;
	tre[x].nm = max(max(tre[x].nl, tre[x].nr), max(max(tre[x*2].nm, tre[x*2+1].nm), tre[x*2].nr+tre[x*2+1].nl));
}

void Lazy(int l, int r, int x)
{
	int m;
	m = (l+r)/2;
	if(tre[x].s==0)
	{
		tre[x*2].dm = tre[x*2].dr = tre[x*2].dl = m-l+1;
		tre[x*2].nm = tre[x*2].nr = tre[x*2].nl = m-l+1;
		tre[x*2+1].dm = tre[x*2+1].dr = tre[x*2+1].dl = r-m;
		tre[x*2+1].nm = tre[x*2+1].nr = tre[x*2+1].nl = r-m;
		if(m!=l)
			tre[x*2].s = tre[x*2].n = tre[x*2].d = 0;
		if(m+1!=r)
			tre[x*2+1].s = tre[x*2+1].n = tre[x*2+1].d = 0;
		tre[x].s = -1;
	}
	if(tre[x].n!=0)
	{
		tre[x*2].dm = tre[x*2].dr = tre[x*2].dl = 0;
		tre[x*2].nm = tre[x*2].nr = tre[x*2].nl = 0;
		tre[x*2+1].dm = tre[x*2+1].dr = tre[x*2+1].dl = 0;
		tre[x*2+1].nm = tre[x*2+1].nr = tre[x*2+1].nl = 0;
		if(m!=l)
			tre[x*2].n = 1, tre[x*2].d = 0;
		if(m+1!=r)
			tre[x*2+1].n = 1, tre[x*2+1].d = 0;
		tre[x].n = tre[x].d = 0;
	}
	if(tre[x].d!=0)
	{
		tre[x*2].dm = tre[x*2].dr = tre[x*2].dl = 0;
		tre[x*2+1].dm = tre[x*2+1].dr = tre[x*2+1].dl = 0;
		if(m!=l)
			tre[x*2].d = 1;
		if(m+1!=r)
			tre[x*2+1].d = 1;
		tre[x].d = 0;
	}
}