【线段树】【P2572】【SCOI2010】序列操作

Description

lxhgww最近收到了一个01序列，序列里面包含了n个数，这些数要么是0，要么是1，现在对于这个序列有五种变换操作和询问操作：

0 a b 把[a, b]区间内的所有数全变成0

1 a b 把[a, b]区间内的所有数全变成1

2 a b 把[a,b]区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1变成0

3 a b 询问[a, b]区间内总共有多少个1

4 a b 询问[a, b]区间内最多有多少个连续的1

对于每一种询问操作，lxhgww都需要给出回答，聪明的程序员们，你们能帮助他吗？

Input

输入数据第一行包括2个数，n和m，分别表示序列的长度和操作数目

第二行包括n个数，表示序列的初始状态

接下来m行，每行3个数，op, a, b，（0<=op<=4，0<=a<=b<n）表示对于区间[a, b]执行标号为op的操作

Output

对于每一个询问操作，输出一行，包括1个数，表示其对应的答案

Hint

对于30%的数据，1<=n, m<=1000

对于100%的数据，1<=n, m<=100000

Solution

测试题……睿智线段树……头一次写多标记线段树写了7k然后爆10分……最后发现标记传错了……

考虑一个区间维护的信息显然有1的个数，连续1长度，左连续1，右连续1。0也同理。标记打上区间置零，赋一，取反。

考虑pushdown操作。

发现这三个标记只能同时存在一个，所以下传的顺序是无所谓的。但是需要考虑打标记的时候标记的重叠问题。具体的，在make_tag的时候，如果打赋1标记，若存在取反标记，则改为打赋0标记。同时把其余标记置为false。区间置0同理。

考虑区间取反的时候，如果存在全部赋值标记，则将赋值标记取反，不打取反标记，否则将取反标记取反。因为把取反写成赋true爆10分了……

大概就这样

我好菜啊……写了7k只有10分

Code

#include <cstdio>
#include <iostream>
#include <algorithm>
#ifdef ONLINE_JUDGE
#define freopen(a, b, c)
#endif
#define rg register
#define ci const int
#define cl const long long

typedef long long int ll;

namespace IPT {
	const int L = 1000000;
	char buf[L], *front=buf, *end=buf;
	char GetChar() {
		if (front == end) {
			end = buf + fread(front = buf, 1, L, stdin);
			if (front == end) return -1;
		}
		return *(front++);
	}
}

template <typename T>
inline void qr(T &x) {
	rg char ch = IPT::GetChar(), lst = ' ';
	while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();
	while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();
	if (lst == '-') x = -x;
}

template <typename T>
inline void ReadDb(T &x) {
	rg char ch = IPT::GetChar(), lst = ' ';
	while ((ch > '9') || (ch < '0')) lst = ch, ch = IPT::GetChar();
	while ((ch >= '0') && (ch <= '9')) x = x * 10 + (ch ^ 48), ch = IPT::GetChar();
	if (ch == '.') {
		ch = IPT::GetChar();
		double base = 1;
		while ((ch >= '0') && (ch <= '9')) x += (ch ^ 48) * ((base *= 0.1)), ch = IPT::GetChar();
	}
	if (lst == '-') x = -x;
}

namespace OPT {
	char buf[120];
}

template <typename T>
inline void qw(T x, const char aft, const bool pt) {
	if (x < 0) {x = -x, putchar('-');}
	rg int top=0;
	do {OPT::buf[++top] = x % 10 + '0';} while ( x /= 10);
	while (top) putchar(OPT::buf[top--]);
	if (pt) putchar(aft);
}

const int maxn = 100010;
const int maxt = 200010;

int n, m;
int MU[maxn];

struct Tag {
	bool zero,one,bk;
	inline void clear() {
		zero = one = bk = false;
	}
};

struct Info {
	int s0, s1, len0, len1, ll0, ll1, rl0, rl1;

	inline void buildit(int _v) {
		if (_v == 1) {
			len1 = ll1 = rl1 = s1 = 1;
		} else {
			len0 = ll0 = rl0 = s0 = 1;
		}
	}

	inline void clear() {
		s0 = s1 = len0 = len1 = ll0 = ll1 = rl0 = rl1 = 0;
	}

	inline Info operator+(const Info &_others) const {
		Info _ret;
		_ret.clear();
		_ret.s0 = this->s0 + _others.s0;
		_ret.s1 = this->s1 + _others.s1;
		_ret.len0 = std::max(std::max(this->len0,_others.len0), this->rl0 + _others.ll0);
		_ret.len1 = std::max(std::max(this->len1,_others.len1), this->rl1 + _others.ll1);
		_ret.ll0 = this->ll0 + (!this->s1) * (_others.ll0);
		_ret.ll1 = this->ll1 + (!this->s0) * (_others.ll1);
		_ret.rl0 = _others.rl0 + (!_others.s1) * (this->rl0);
		_ret.rl1 = _others.rl1 + (!_others.s0) * (this->rl1);
		return _ret;
	}

	inline void reset(ci k) {
		if (k == 0) {
			this->s0 = this->ll0 = this->len0 = this->rl0 = this->s0 + this->s1;
			this->s1 = this->len1 = this->ll1 = this->rl1 = 0;
		} else if (k == 1) {
			this->s1 = this->ll1 = this->len1 = this->rl1 = this->s0 + this->s1;
			this->s0 = this->len0 = this->ll0 = this->rl0 = 0;
		} else {
			std::swap(this->s0,this->s1);
			std::swap(this->ll0,this->ll1);
			std::swap(this->len0,this->len1);
			std::swap(this->rl0,this->rl1);
		}
	}

};

struct Tree {
	Tree *ls, *rs;
	int l, r;
	Tag tg;
	Info v;

	inline void pushup() {
		this->v.clear();
		if((this->ls) && (!this->rs)) this->v = this->ls->v;
		else if((this->rs) && (!this->ls)) this->v = this->rs->v;
		else this->v = this->ls->v + this->rs->v;
	}

	inline void maketag(ci k) {
		if(k == 0) {
			this->tg.zero = true;
			this->v.reset(0);
			this->tg.one = this->tg.bk = false;
		} else if(k == 1) {
			this->tg.one = true;
			this->v.reset(1);
			this->tg.zero = this->tg.bk = false;
		} else {
			if(this->tg.one) {
				this->v.reset(0);
				std::swap(this->tg.one,this->tg.zero);
			} else if(this->tg.zero) {
				this->v.reset(1);
				std::swap(this->tg.one,this->tg.zero);
			} else {
				this->v.reset(2);
				this->tg.bk ^= 1;
			}
		}
	}

	inline void pushdown() {
		if (this->tg.zero) {
			if(this->ls) this->ls->maketag(0);
			if(this->rs) this->rs->maketag(0);
		} else if (this->tg.one) {
			if(this->ls) this->ls->maketag(1);
			if(this->rs) this->rs->maketag(1);
		} else if(this->tg.bk) {
			if(this->ls) this->ls->maketag(2);
			if(this->rs) this->rs->maketag(2);
		}
		this->tg.clear();
	}
};
Tree *pool[maxt], qwq[maxt], *rot;
int top;

struct Ret {
	int l,r,ans;
	bool isall;
	inline void clear() {
		l = r = ans = isall = 0;
	}
};

void buildpool();
void buildroot();
void build(Tree*, ci, ci);
void update(Tree*, ci, ci, ci);
int ask3(Tree*, ci, ci);
Ret ask4(Tree*, ci, ci);

int main() {
	freopen("data.in", "r", stdin);
	qr(n); qr(m);
	for (rg int i = 1; i <= n; ++i) qr(MU[i]);
	buildpool();
	buildroot();
	build(rot, 1, n);
	int a, b, c;
	while (m--) {
		a = b = c = 0;
		qr(a); qr(b); qr(c);
		++b;++c;
		switch(a) {
			case 0: {
				update(rot, b, c, 0);
				break;
			}
			case 1: {
				update(rot, b, c, 1);
				break;
			}
			case 2: {
				update(rot, b, c, 2);
				break;
			}
			case 3: {
				qw(ask3(rot, b, c), '\n', true);
				break;
			}
			case 4: {
				qw(ask4(rot, b, c).ans, '\n', true);
				break;
			}
		}
	}
}

void buildpool() {
	for (rg int i = 0; i < maxt; ++i) pool[i] = qwq+i;
	top = maxt - 1;
}

void buildroot() {
	rot = pool[top--];
	rot->l = 1; rot->r = n;
}

void build(Tree *u, ci l, ci r) {
	if(l == r) {u->v.buildit(MU[l]); return;}
	int mid = (l + r) >> 1;
	if (l <= mid) {
		u->ls = pool[top--];
		u->ls->l = l; u->ls->r = mid;
		build(u->ls, l, mid);
	}
	if(mid < r) {
		u->rs = pool[top--];
		u->rs->l = mid+1; u->rs->r = r;
		build(u->rs, mid+1, r);
	}
	u->pushup();
}

void update(Tree *u, ci l, ci r, ci v) {
	u->pushdown();
	if((u->l >= l) && (u->r <= r)) {
		u->maketag(v);return;
	}
	if((u->l > r) || (u->r < l)) return;
	if(u->ls) update(u->ls, l, r, v);
	if(u->rs) update(u->rs, l, r, v);
	u->pushup();
}

int ask3(Tree *u, ci l, ci r) {
	u->pushdown();
	if((u->l >= l) && (u->r <= r)) return u->v.s1;
	else if((u->l > r) || (u->r < l)) return 0;
	int _ret = 0;
	if(u->ls) _ret = ask3(u->ls, l ,r);
	if(u->rs) _ret += ask3(u->rs, l, r);
	return _ret;
}

Ret ask4(Tree *u, ci l, ci r) {
	u->pushdown();
	if((u->l >= l) && (u->r <= r)) {
		return (Ret){u->v.ll1, u->v.rl1, u->v.len1, u->v.s0 == 0};
	}
	if((u->l > r) || (u->r < l)) {
		return (Ret){0, 0, 0, 0};
	}
	Ret rl,rr,ret;
	rl.clear();rr.clear();ret.clear();
	if(u->ls) rl = ask4(u->ls, l, r);
	if(u->rs) rr = ask4(u->rs, l, r);
	ret.l = rl.l + rl.isall * rr.l;
	ret.r = rr.r + rr.isall * rl.r;
	ret.ans = std::max(std::max(rl.ans, rr.ans), rl.r + rr.l);
	return ret;
}

Summary

在多标记下传时，考虑下传顺序间的影响，以及下传新标记时，旧标记对新标记的影响。

另外比赛时如果正解写挂一定要及时写暴力……