约会安排 HDU - 4553 区间合并

一、内容

寒假来了，又到了小明和女神们约会的季节。
　　小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。
　　我们已知小明一共有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

二、思路

• 用2个线段树分别维护男生预约的时间段和女生预约的时间段。 线段树里面保存的是最大连续子段和，空闲时间为1，预约了的话就是0。
• 当男生来预约的时候，只需要修改男生的线段树即可。 而当女生来预约的时候若在男生的线段树里面找不到空闲时间再去女生线段树里面查找，若找到就修改男生和女生2个线段树（因为女生可以无视基友）。
• 每次查询修改时候进行区间下放。
• 查询的时候分成3种情况，首先如果调用查询函数代表一定有那么多空闲时间。
  1.在左区间
  2.左边区间和右边区间合并得来的答案，这种情况直接返回这个区间的左端点即可。
  3.在右区间

三、代码

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e5 + 5;
struct Node {
	int lmax, rmax, ans;// lmax代表从左端点开始的最大连续区间和  rmax代表从右端点开始向左的最大连续区间和 
	//ans是最大的连续区间和 
} b[N << 2], g[N << 2];
int t, n, m, x, y;
char s[10]; 
void pushup(int id, int l, int r) {
	//st >=0 更新b st>= 1更新g
	int mid = (l + r) >> 1; 
	Node &root = b[id], &lt = b[id << 1], &rt = b[id << 1 | 1];
	root.lmax = lt.lmax + (lt.lmax == (mid - l + 1) ? rt.lmax : 0); //若左边 最大和是整个区间那么就再加上右区间的lmax
	root.rmax = rt.rmax + (rt.rmax == (r - mid) ? lt.rmax : 0);
	root.ans = max(max(lt.ans, rt.ans), lt.rmax + rt.lmax);
	
	Node &groot = g[id], &glt = g[id << 1], &grt = g[id << 1 | 1];
	groot.lmax = glt.lmax + (glt.lmax == (mid - l + 1) ? grt.lmax : 0);  
	groot.rmax = grt.rmax + (grt.rmax == (r - mid) ? glt.rmax : 0);
	groot.ans = max(max(glt.ans, grt.ans), glt.rmax + grt.lmax);		
}
void pushdown(int id, int l, int r) {
	//b g数组都进行下放
	int mid = (l + r) >> 1; 
	Node &root = b[id], &lt = b[id << 1], &rt = b[id << 1 | 1];
	if (root.ans == r - l + 1) { //说明是学习导致的下放 
		lt.lmax = lt.rmax = lt.ans = mid - l + 1;
		rt.lmax = rt.rmax = rt.ans = r - mid;
	}
	if (root.ans == 0) { //约会导致的下放 
		lt.lmax = lt.rmax = lt.ans = 0;
		rt.lmax = rt.rmax = rt.ans = 0;		
	}
	//引用只能赋值一次 
	Node &groot = g[id], &glt = g[id << 1], &grt = g[id << 1 | 1];
	if (groot.ans == r - l + 1) { //说明是学习导致的下放 
		glt.lmax = glt.rmax = glt.ans = mid - l + 1;
		grt.lmax = grt.rmax = grt.ans = r - mid;
	}
	if (groot.ans == 0) { //约会导致的下放 
		glt.lmax = glt.rmax = glt.ans = 0;
		grt.lmax = grt.rmax = grt.ans = 0;		
	}	
}
void build(int id, int l, int r) {
	if (l == r) {
		b[id].ans = b[id].lmax = b[id].rmax = g[id].ans = g[id].lmax = g[id].rmax = 1;
		return ;
	}
	int mid = (l + r) >> 1;
	build(id << 1, l, mid);
	build(id << 1 | 1, mid + 1, r);
	pushup(id, l, r);
} 
void update(int id, int l, int r, int x, int y, int st) {
	if (x <= l && r <= y) {
		if (st == 0) { //代表男生修改为0
		 	b[id].lmax = b[id].rmax = b[id].ans = 0;
		} else { //男女生都修改为0  st==2代表男女生都修改为1 
		 	b[id].lmax = b[id].rmax = b[id].ans = (st == 1 ? 0 : r - l + 1);
		 	g[id].lmax = g[id].rmax = g[id].ans = (st == 1 ? 0 : r - l + 1);						
		} 
		return ;
	}
	pushdown(id, l, r);
	int mid = (l + r) >> 1;
	if (x <= mid) update(id << 1, l, mid, x, y, st);
	if (y > mid) update(id << 1 | 1, mid + 1, r, x, y, st);
	pushup(id, l, r); 
}
int query(int id, int l, int r, int x, int st) {
	if (l == r) return l; //查询到单点了 只能返回了 由于我们查询之前判断过，代表一定能查询到结果才进行查询 
	pushdown(id, l, r);
	int mid = (l + r) >> 1;
	//3种情况 要么是在左边区间， 如果不在左边区间那么再判断是否是左边区间和右边区间的并，若还不是只能在右区间了
	if (st == 0) { //对b线段树进行查询 
		Node &root = b[id], &lt = b[id << 1], &rt = b[id << 1 | 1];
		if (lt.ans >= x) {
			return query(id << 1, l, mid, x, st);
		} else if ((lt.rmax + rt.lmax) >= x) {
			return mid - lt.rmax + 1;
		} else {
			return query(id << 1 | 1, mid + 1, r, x, st);
		}
	} 
	if (st == 1) {
		Node &groot = g[id], &glt = g[id << 1], &grt = g[id << 1 | 1];
		if (glt.ans >= x) {
			return query(id << 1, l, mid, x, st);
		} else if ((glt.rmax + grt.lmax) >= x) {
			return mid - glt.rmax + 1;
		} else {
			return query(id << 1 | 1, mid + 1, r, x, st);
		}		
	}
}
int main() {
	scanf("%d", &t);
	for (int ci = 1; ci <= t; ci++) {
		scanf("%d%d", &n, &m);
		build(1, 1, n);
		printf("Case %d:\n", ci);
		for (int i = 1; i <= m; i++) {
			scanf("%s%d", s, &x);
			if (s[0] == 'D') {
				if (b[1].ans >= x) {
					int t = query(1, 1, n, x, 0);
					update(1, 1, n, t, t + x - 1, 0); 
					printf("%d,let's fly\n", t); 
				} else {
					printf("fly with yourself\n");
				}
			} else if (s[0] == 'N') {
				if (b[1].ans >= x) {
					int t = query(1, 1, n, x, 0); // 0代表在b数组进行查询 
					update(1, 1, n, t, t + x - 1, 1); //1代表b、g数组的该区间都更新为0  2代表更新为1 
					printf("%d,don't put my gezi\n", t);
				} else if (g[1].ans >= x) {
					int t = query(1, 1, n, x, 1);
					update(1, 1, n, t, t + x - 1, 1); 
					printf("%d,don't put my gezi\n", t);
				} else {
					printf("wait for me\n");
				}
			} else {
				scanf("%d", &y);
				update(1, 1, n, x, y, 2);
				printf("I am the hope of chinese chengxuyuan!!\n");
			}
		}
	} 
	return 0;
}