（线段树区间赋值）CSU 1942

题意：

一个串（串中只有26个小写字母），选一个区间进行排序，进行100000次，输出最后的串。

分析：

比赛的时候很懵逼，感觉这题跟之前的额大崩龙有点像，但是没多想，也怪自己太菜了。

确实是真的像，甚至是一模一样啊。

对于每次排序只需要进行一次类似计数排序的的操作即可，26个字符，进行26次区间赋值即可。理论上时间能过得去。

代码：

#include <queue>
#include <string>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>


using namespace     std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;

#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-8)
#define fi first
#define se second

//--------------------------

const ll mod = 1000000007;
const int maxn = 100010;


char str[maxn];
int n;
int q;

struct Node {
    int left, right;
    int num[26];
    int lazy;
} node[maxn << 2];

void push_up(int n) {
    for(int i = 0; i < 26; i++) {
        node[n].num[i] = node[n << 1].num[i] + node[n << 1 | 1].num[i];
    }
}

void push_down(int n) {
    if(node[n].lazy != -1) {
        node[n << 1].lazy = node[n << 1 | 1].lazy = node[n].lazy;
        memset(node[n << 1].num, 0, sizeof(node[n << 1].num));
        memset(node[n << 1 | 1].num, 0, sizeof(node[n << 1 | 1].num));
        node[n << 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) - (node[n].right - node[n].left + 1) / 2;
        node[n << 1 | 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) / 2;
        node[n].lazy = -1;
    }
}

void update(int n, int left, int right, char val) {
    if(node[n].left >= left && node[n].right <= right) {
        node[n].lazy = val - 'a';
        memset(node[n].num, 0, sizeof(node[n].num));
        node[n].num[node[n].lazy] = node[n].right - node[n].left + 1;
        return ;
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    if(mid >= left)update(n << 1, left, right, val);
    if(mid < right)update(n << 1 | 1, left, right, val);
    push_up(n);
}

int query(int n, int left, int right, char val) {
    if(node[n].left >= left && node[n].right <= right) {
        return node[n].num[val - 'a'];
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    int sum = 0;
    if(mid >= left)sum += query(n << 1, left, right, val);
    if(mid < right)sum += query(n << 1 | 1, left, right, val);
    return sum;
}


void build(int n, int left, int right) {
    node[n].left = left;
    node[n].right = right;
    node[n].lazy = -1;
    if(left == right) {
        node[n].num[str[left] - 'a'] = 1;
        return ;
    }
    int mid = (left + right) >> 1;
    build(n << 1, left, mid);
    build(n << 1 | 1, mid + 1, right);
    push_up(n);
}

void print(int n) {
    if(node[n].left == node[n].right) {
        for(int i = 0; i < 26; i++) {
            if(node[n].num[i] != 0) {
                printf("%c", i + 'a');
                break;
            }
        }
        return ;
    }
    push_down(n);
    print(n << 1);
    print(n << 1 | 1);
}

void solve() {
    while(~scanf("%d%d", &n, &q)) {
        memset(node, 0, sizeof(node));
        scanf("%s", str + 1);
        build(1, 1, n);
        while(q--) {
            int l, r, op;
            scanf("%d%d%d", &l, &r, &op);
            int num[26] = {0};
            for(int i = 0; i < 26; i++) {
                num[i] = query(1, l, r, i + 'a');
            }
            if(op == 1) {
                for(int i = 0; i < 26; i++) {
                    if(num[i] > 0) {
                        update(1, l, l + num[i] - 1, i + 'a');
                        l += num[i];
                    }
                }
            } else {
                for(int i = 25; i >= 0; i--) {
                    if(num[i] > 0) {
                        update(1, l, l + num[i] - 1, i + 'a');
                        l += num[i];
                    }
                }
            }
        }
        print(1);
        puts("");
    }



}

int main() {
#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
#endif
    solve();
    return 0;
}