CF-558-E. A Simple Task【线段树区间set】

传送门
给定一个长度为$N$字符串，均为小写字母
对区间进行$M$次排序，从小到大或者从大到小
求，最后的字符串长什么样

分析

这里发现，小写字母只有26个，对于每次排序操作，就让这些字符单独排序，正序就先排a，在a排完的位置后排b，以此类推

那么，就构建26棵线段树，维护当前树表示字母出现的位置
对于排序来说，对某个区间字母进行排序，为区间$set$，要知道有多少个字母进行排序，又是区间$query$，所以线段树支持这两个功能足以，为了保证复杂度，懒惰标记是要有的

代码

//CF558E 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

char arr[MAX_N];

struct Tr {
	int k, l, r, lazy;
}tr[MAX_N<<4];
int root[MAX_N];
int indx = 0;

int mk() {
	tr[++indx].lazy = -1;
	return indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

void calc(int& rt, int len, int lazy) {
	if (!rt) rt = mk();
	tr[rt].k = len * lazy;
	tr[rt].lazy = lazy;
}

void push_down(int rt, int l, int r) {
	if (tr[rt].lazy == -1) return;
	int mid = l + ((r-l)>>1);
	calc(tr[rt].l, mid-l+1, tr[rt].lazy);
	calc(tr[rt].r, r-mid, tr[rt].lazy);
	tr[rt].lazy = -1;
}

void update(int& rt, int l, int r, int x, int y, int k) {
	if (x > y) return;
	if (!rt) rt = mk();
	if (x <= l && r <= y) {
		calc(rt, r-l+1, k);
		return;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, y, k);
	if (y  > mid) update(tr[rt].r, mid+1, r, x, y, k);
	push_up(rt);
}

int query(int rt, int l, int r, int x, int y) {
	if (x > y) return 0;
	if (!rt) return 0;
	if (x <= l && r <= y) {
		return tr[rt].k;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (y <= mid) return query(tr[rt].l, l, mid, x, y);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x, y);
	return query(tr[rt].l, l, mid, x, y) + query(tr[rt].r, mid+1, r, x, y);
}

void flush(int rt, int l, int r, int c) {
	if (!rt) return;
	if (l == r) {
		if (tr[rt].k) {
			arr[l] = 'a'+c-1;
		}
		return;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	flush(tr[rt].l, l, mid, c);
	flush(tr[rt].r, mid+1, r, c);
}

int cnt[27];

void sort(int l, int r) {
	memset(cnt, 0, sizeof cnt);
	for (int i = 1; i <= 26; ++i) {
		cnt[i] = query(root[i], 1, N, l, r);
		cnt[i] += cnt[i-1];
	}
	for (int i = 1; i <= 26; ++i) {
		update(root[i], 1, N, l, l+cnt[i-1]-1, 0);
		update(root[i], 1, N, l+cnt[i-1], l+cnt[i]-1, 1);
		update(root[i], 1, N, l+cnt[i], r, 0);
	}
}

void rev(int l, int r) {
	memset(cnt, 0, sizeof cnt);
	for (int i = 1; i <= 26; ++i) {
		cnt[i] = query(root[i], 1, N, l, r);
		cnt[i] += cnt[i-1];
	}
	for (int i = 1; i <= 26; ++i) {
		update(root[i], 1, N, r-cnt[i-1]+1, r, 0);
		update(root[i], 1, N, r-cnt[i]+1, r-cnt[i-1], 1);
		update(root[i], 1, N, l, r-cnt[i], 0);
	}
}

void show() {
	for (int i = 1; i <= 26; ++i) {
		flush(root[i], 1, N, i);
	}
}

void solve(){
	sc("%d%d", &N, &M);
	sc("%s", arr+1);
	for (int i = 1; i <= N; ++i) {
		update(root[arr[i]-'a'+1], 1, N, i, i, 1);
	}
	
	int opt, l, r;
	for (int i = 1; i <= M; ++i) {
		sc("%d%d%d", &l, &r, &opt);
		if (opt==1) {
			sort(l, r);
		} else {
			rev(l, r);
		}
	}

	show();
	pr("%s", arr+1);
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}