CF558E A Simple Task

题目大意： 给定一个长度不超过10^5的字符串（小写英文字母），和不超过5000个操作。

每个操作 L R K 表示给区间[L,R]的字符串排序，K=1为升序，K=0为降序。

最后输出最终的字符串

首先这么想想，对于一段区间的排序，排完序的样子和排序之前每个字母的位置并没有关系，而是和每一个字母出现的次数有关。所以我们对于每一次操作，统计出区间中每一个字母出现了多少次，然后按字典序排序就行。更确切的说，就是这个区间中的哪一个部分都改成某一个字母，区间修改。

既然是区间修改，那么就可以用线段树实现。不过这样的话，打lazy标记就显得不是很方便。为此，我们可以开26个线段树，每一个字母开一个长度为n的权值线段树，如果第i为是这个字母，我们就把这一位改成1,然后统计区间中这个字母有多少个，就相当于求区间和了。至于修改，那就是将这个字母所在线段树的区间全都改成1.然后把操作区间的别的地方改成0即可。

举个栗子：

acbcaab

然后将[1, 6]按升序排序。

那么我们首先分别在a, b, c所在的线段树上查到了[1, 6]的区间和，即统计出了每个字母的出现次数。

然后排序的时候，对于a所在的线段树，我们将[1, 3]都改成了1，[4, 6]改成了0；对于b所在线段树，我们将[4, 4]改成了1，[1, 3]和[5, 6]改成了0；对于c，我们将[5, 6]改成了1，[1, 4]改成了0.

这样这个区间就排完序了。

那么怎么输出最终答案呢？

只要对于每一位，暴力的从0到26循环，看哪个字母在这一位上是1，就说明这一位是这个字母了。

配合break，时间复杂度最坏为O(nlogn * 26)

 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<cstdlib>
 #include<cctype>
 #include<vector>
 #include<stack>
 #include<queue>
 using namespace std;
 #define enter printf("\n")
 #define space printf(" ")
 #define Mem(a) memset(a, 0, sizeof(a))
 typedef long long ll;
 typedef double db;
 const int INF = 0x3f3f3f3f;
 const db eps = 1e-;
 const int maxn = 2e7 + ;
 inline int read()
 {
     int ans = ;
     char ch = getchar(), last = ' ';
     while(!isdigit(ch)) {last = ch; ch = getchar();}
     while(isdigit(ch))
     {
         ans = ans *  + ch - ''; ch = getchar();
     }
     if(last == '-') ans = -ans;
     return ans;
 }
 inline void write(ll x)
 {
     if(x < ) x = -x, putchar('-');
     if(x >= ) write(x / );
     putchar('' + x % );
 }

 int n, q;
 char s[];

 int cnt = , root[], lson[maxn], rson[maxn], l[maxn], r[maxn];
 //lson[now]和rson[now]分别记录now的左右儿子的编号，代替了now << 1和 now <<1 | 1
 int sum[maxn], lazy[maxn];
 void build(int& now, int L, int R)    //我这个写法是先吧所有点开好了，不是动态开点（竟然比某位大佬的动态开点快）
 {
     now = ++cnt; lazy[now] = -;
     l[now] = L; r[now] = R;
     if(L == R) return;
     int mid = (L + R) >> ;
     build(lson[now], L, mid);
     build(rson[now], mid + , R);
 }
 void add(int now, int id)
 {
     if(l[now] == r[now]) {sum[now]++; return;}
     int mid = (l[now] + r[now]) >> ;
     if(id <= mid) add(lson[now], id);
     else add(rson[now], id);
     sum[now] = sum[lson[now]] + sum[rson[now]];
 }
 void pushdown(int now)
 {
     if(lazy[now] != -)        //因为lazy[now]=0代表将区间都改为0，所以没有标记要换一个记号
     {
         sum[lson[now]] = (r[lson[now]] - l[lson[now]] + ) * lazy[now];
         sum[rson[now]] = (r[rson[now]] - l[rson[now]] + ) * lazy[now];
         lazy[lson[now]] = lazy[now];
         lazy[rson[now]] = lazy[now];
         lazy[now] = -;
     }

 }
 void update(int now, int L, int R, int d)
 {
     if(L == l[now] && R == r[now])
     {
         sum[now] = (r[now] - l[now] + ) * d;
         lazy[now] = d; return;
     }
     pushdown(now);
     int mid = (l[now] + r[now]) >> ;
     if(R <= mid) update(lson[now], L, R, d);
     else if(L > mid) update(rson[now], L, R, d);
     else {update(lson[now], L, mid, d); update(rson[now], mid + , R, d);}
     sum[now] = sum[lson[now]] + sum[rson[now]];
 }
 int query(int now, int L, int R)
 {
     if(!sum[now]) return ;        //优化
     if(L == l[now] && R == r[now]) return sum[now];
     pushdown(now);
     int mid = (l[now] + r[now]) >> ;
     if(R <= mid) return query(lson[now], L, R);
     else if(L > mid) return query(rson[now], L, R);
     else return query(lson[now], L, mid) + query(rson[now], mid + , R);
 }

 int main()
 {
     n = read(); q = read();
     scanf("%s", s + );
     for(int i = ; i < ; ++i) build(root[i], , n);
     for(int i = ; i <= n; ++i)    add(root[s[i] - 'a'], i);
     for(int i = ; i <= q; ++i)
     {
         int L = read(), R = read(), k = read();
         if(k)
         {
             int pre = L - ;
             for(int j = ; j < ; ++j)     //枚举每一棵线段树
             {
                 int ssum = query(root[j], L, R);
                 if(ssum)
                 {
                     update(root[j],L,R,);        //先都改成0，在局部覆盖1
                     update(root[j], pre + , pre + ssum, );
                 }
                 pre += ssum;
             }
         }
         else
         {
             int pre = L - ;
             for(int j = ; j >= ; --j)     //降序，就倒着枚举
             {
                 int ssum = query(root[j], L, R);
                 if(ssum)
                 {
                     update(root[j],L,R,);
                     update(root[j], pre + , pre + ssum, );
                 }
                 pre += ssum;
             }
         }
     }
     for(int i = ; i <= n; ++i)        //很暴力的查询
         for(int j = ; j < ; ++j)
             if(query(root[j], i, i)) {printf("%c", 'a' + j); break;}
     enter;
     return ;
 }

这道题时限5秒，然而还特别容易TLE，所以得做好常数优化工作。

据说某位大佬线段树上每个节点记录26个字母出现的情况，所以只开了一棵线段树，自然就十分的快了，毫无TLE的烦恼。（很显然，我不会写，要不就不讲上述的方法了……）