题目大意就是给一个字符串，然后多个操作。每次操作能够把每一段区间的字符进行升序或者降序排序，问终于的字符串是如何的。
做法的话就是用线段树维护区间和
一開始仅仅考虑字符串中字符‘a‘的情况。如果操作区间[L,R]中有x个‘a‘,那么一次操作后，这x个‘a‘要么去最左(升序)。要么去最右(降序),我们能够建立一颗线段树来维护这种操作，字符‘a‘出现的位置值为1，否则为0，那么q次操作后，最后值为1的地方填的就是‘a‘了。
然后，在考虑字符‘a‘和‘b‘的情况，操作的情况和上面类似，字符‘a‘和‘b‘出现的位置值为1。否则为0，q次操作后，假设一个位置的值为1。而且该位置没有填写‘a‘。那么这个位置就填写‘b‘。
接下来的情况以此类推，考虑abc。abcd，......，abcd...z。
时间复杂度O(26*(n+q)logn)。
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<climits>
#include<list>
#include<iomanip>
#include<stack>
#include<set>
using namespace std;
struct Tree
{
int l,r,sum;
}tree[int(4e5)];
void create(int l,int r,int k)
{
tree[k].l=l;
tree[k].r=r;
tree[k].sum=0;
if(l==r)
return;
int m=l+r>>1;
create(l,m,k<<1);
create(m+1,r,k<<1|1);
}
void lazy(int k)
{
if(tree[k].l!=tree[k].r&&tree[k].sum!=tree[k<<1].sum+tree[k<<1|1].sum)
{
if(tree[k].sum==0)
tree[k<<1].sum=tree[k<<1|1].sum=0;
else
{
tree[k<<1].sum=tree[k<<1].r-tree[k<<1].l+1;
tree[k<<1|1].sum=tree[k<<1|1].r-tree[k<<1|1].l+1;
}
}
}
void update(int l,int r,bool flag,int k)
{
lazy(k);
if(l==tree[k].l&&r==tree[k].r)
{
tree[k].sum=flag?r-l+1:0;
return;
}
int m=tree[k].l+tree[k].r>>1;
if(r<=m)
update(l,r,flag,k<<1);
else if(l>m)
update(l,r,flag,k<<1|1);
else
{
update(l,m,flag,k<<1);
update(m+1,r,flag,k<<1|1);
}
tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;
}
int seek(int l,int r,int k)
{
lazy(k);
if(l==tree[k].l&&r==tree[k].r)
return tree[k].sum;
int m=tree[k].l+tree[k].r>>1;
if(r<=m)
return seek(l,r,k<<1);
if(l>m)
return seek(l,r,k<<1|1);
return seek(l,m,k<<1)+seek(m+1,r,k<<1|1);
}
void update(int l,int r,bool flag)
{
int t=seek(l,r,1);
if(flag)
{
if(l<=l+t-1)
update(l,l+t-1,1,1);
if(l+t<=r)
update(l+t,r,0,1);
}
else
{
if(r-t+1<=r)
update(r-t+1,r,1,1);
if(l<=r-t)
update(l,r-t,0,1);
}
}
struct Box
{
int l,r;
bool flag;
}box[int(1e5)+10];
int ans[int(1e5)+10];
int main()
{
int n,q;
cin>>n>>q;
create(1,n,1);
string s;
cin>>s;
for(int i=0;i<q;i++)
cin>>box[i].l>>box[i].r>>box[i].flag;
for(int i=0;i<26;i++)
{
update(1,n,0,1);
for(int j=0;j<n;j++)
if(s[j]<=i+‘a‘)
update(j+1,j+1,1,1);
for(int j=0;j<q;j++)
update(box[j].l,box[j].r,box[j].flag);
for(int j=0;j<n;j++)
if(ans[j]==0&&seek(j+1,j+1,1)==1)
ans[j]=i+‘a‘;
}
for(int i=0;i<n;i++)
putchar(ans[i]);
}
time limit per test
5 seconds
memory limit per test
512 megabytes
input
standard input
output
standard output
This task is very simple. Given a string S of length n and q queries
each query is on the format i j k which
means sort the substring consisting of the characters from i to j in
non-decreasing order if k?=?1 or in non-increasing order if k?=?0.
Output the final string after applying the queries.
Input
The first line will contain two integers n,?q (1?≤?n?≤?105, 0?≤?q?≤?50?000),
the length of the string and the number of queries respectively.
Next line contains a string S itself. It contains only lowercase English letters.
Next q lines will contain three integers each i,?j,?k (1?≤?i?≤?j?≤?n, 
).
Output
Output one line, the string S after applying the queries.
Sample test(s)
input
10 5 abacdabcda 7 10 0 5 8 1 1 4 0 3 6 0 7 10 1
output
cbcaaaabdd
input
10 1 agjucbvdfk 1 10 1
output
abcdfgjkuv
Note
First sample test explanation:
