Codeforces 558E A Simple Task (计数排序&&线段树优化)

题目链接：http://codeforces.com/contest/558/problem/E

E. A Simple Task

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:

题意：就是说给你一个n长度字符串，进行q次操作，k=1时要对着一个区间的字符进行

非递减排序，k=2时相反，最后输出操作后的字符串

思路：正常写法肯定超时，那就可肯定要优化，采取线段树优化查询和更改都是log2(n)

线短路算法：https://blog.csdn.net/zearot/article/details/48299459

代码有解析，我就不多说了！

上代码：

 #include<stdio.h>
 #include<iostream>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 const int maxn=;
 #define lson(x) x<<1
 #define rson(x) x<<1|1
 #define L(x) tree[x].l;
 #define R(x) tree[x].r;
 #define Hav[x] tree[x].hav
 #define Lazy(x) tree[x].lazy
 char ans[maxn],str[maxn];
 int cnt[];
 struct Segtree  //声明26棵树来存每个字母
 {
     int l,r,hav,m,lazy;
 }tree[][maxn<<];
 void pushup(int root,int id)  //区间求和，因为一个父区间中某个字母的个数是所有子区间字母个数的和
 {
     tree[id][root].hav=tree[id][root<<].hav+tree[id][root<<|].hav;
 }
 void pushdown(int root,int id) //下推标记，在这过程中将所个区间全部填满，（为什么填满要看主函数）
 {
     if(tree[id][root].lazy<) return;
     tree[id][root<<].hav=(tree[id][root<<].r-tree[id][root<<].l)*tree[id][root].lazy;
     tree[id][root<<].lazy=tree[id][root].lazy;
     tree[id][root<<|].hav=(tree[id][root<<|].r-tree[id][root<<|].l)*tree[id][root].lazy;
     tree[id][root<<|].lazy=tree[id][root].lazy;
     tree[id][root].lazy=-;  //父标记删除，子标记续上
 }
 //void build(int l,int r,int root,int id)
 //{ //建一颗总长度为r-l+1的树，其中第一个父节点区间长度最大，处于树的顶端，剩下的依次减少，且相互之间不能重复
 //    int mid=(l+r)>>1;
 //    tree[id][root].m=mid;  //记录中间节点，中后可能会使用（我后面代码有的时候没有使用）
 //    tree[id][root].l=l;
 //    tree[id][root].r=r;
 //    tree[id][root].lazy=-1;  //标记复原位
 //    if(r-l==1)   //按模板来说应该是r==l时才进入，但是主函数中字符数组存值是从0--n-1，
 //    {  //但是我建图的时候用的是1--n+1，其实n+1并没有，所以就相当于这个时候已经到树的最底部了
 //        //这一点多做一些题就会学到好些骚操作
 //        tree[id][root].hav=(str[l-1]=='a'+id);
 //        return;
 //    }
 //    build(l,mid,root<<1,id);
 //    build(mid+1,r,root<<1|1,id);
 //    pushup(root,id);
 //}
 void build(int l,int r,int n,int id)
 
 {
 
     int m=(l+r)>>;
 
     tree[id][n].l=l;
 
     tree[id][n].r=r;
 
     tree[id][n].m=m;
 
     tree[id][n].lazy=-;
     if(r-l==)
     {
         tree[id][n].hav=(str[l-]=='a'+id);
         return;
     }
 
     if(r-l==)
 
     {
 
         tree[id][n].hav=(str[l-]=='a'+id);
 
         return;
 
     }
 
     build(l,m,n<<,id);
     //因为当(n+n+1)>>1的值为n，一旦加一，那就超范围了
     //而且本题再给树底部赋值的时候是用str[l-1]来判断的，由此可见，Segtree结构体里面存的范围和实际操作相差一
     build(m,r,n<<|,id);  //————————我的代码是这里错了，我写的是“m+1”——————————————
 
     pushup(n,id);
 
 }
 //void update(int l,int r,int root,int ops,int id)
 //{ //更新操作，把给出的这一部分区间全部填满（这里说的全部填满就是tree[id][root].hav=(tree[id][root].r-tree[id][root].l)*1（数字）;）
 //    if(tree[id][root].l==l && tree[id][root].r==r)
 //    {
 //        tree[id][root].hav=(tree[id][root].r-tree[id][root].l)*ops;
 //        tree[id][root].lazy=ops;
 //        return;
 //    }
 //    //先下推标记，要不然有的区间还没更新就去查找就会错
 //    pushdown(root,id);
 //    int mid=(tree[id][root].l+tree[id][root].r)>>1;
 //    if(r<=mid) //满足这一个或下一个条件就说明所求区间就在此父节点的一个子区间内
 //    {
 //        update(l,r,root<<1,ops,id);
 //    }
 //    else if(l>=mid)
 //    {
 //        update(l,r,root<<1|1,ops,id);
 //    }
 //    else
 //    {
 //        update(l,mid,root<<1,ops,id);
 //        update(mid,r,root<<1|1,ops,id);
 //    }
 //    pushup(root,id);
 //}
 void update(int l,int r,int n,int op,int id)
 
 {
 
     if(tree[id][n].l==l && tree[id][n].r==r)
 
     {
 
         tree[id][n].hav=(tree[id][n].r-tree[id][n].l)*op;
 
         tree[id][n].lazy=op;
 
         return;
 
     }
 
     pushdown(n,id);
 
     if(r<=tree[id][n].m)update(l,r,n<<,op,id);
 
     else if(l>=tree[id][n].m)update(l,r,n<<|,op,id);
 
     else
 
     {
 
         update(l,tree[id][n].m,n<<,op,id);
 
         update(tree[id][n].m,r,n<<|,op,id);
 
     }
 
     pushup(n,id);
 
 }
 int query(int l,int r,int n,int id)
 
 {
 
     if(tree[id][n].l==l && tree[id][n].r==r)
 
         return tree[id][n].hav;
 
     pushdown(n,id);
 
     if(r<=tree[id][n].m)
 
         return query(l,r,n<<,id);
 
     if(l>=tree[id][n].m)
 
         return query(l,r,n<<|,id);
 
     return query(l,tree[id][n].m,n<<,id)
 
             +query(tree[id][n].m,r,n<<|,id); //————————这里的tree[id][n].m也不能多加一————————————————
 
 }
 //int query(int l,int r,int root,int id)
 //{  //查找和更新大多都一样
 //    if(tree[id][root].l==l && tree[id][root].r==r)
 //    {
 //        return tree[id][root].hav;
 //    }
 //    pushdown(root,id);
 //    int mid=(tree[id][root].l+tree[id][root].r)>>1;
 //    if(r<=mid) return query(l,r,root<<1,id);
 //    else if(l>=mid) return query(l,r,root<<1|1,id);
 //    return query(l,mid,root<<1,id)+query(mid+1,r,root<<1|1,id);
 //}
 //int main()
 //{
 //    int n,q;
 //    scanf("%d%d",&n,&q);
 //    scanf("%s",str);
 //    for(int i=0;i<26;++i) build(1,n+1,1,i);
 //    int l,r,k;
 //    while(q--)
 //    {
 //        scanf("%d%d%d",&l,&r,&k);
 //        for(int i=0;i<26;++i)
 //        {
 //            cnt[i]=query(l,r+1,1,i);
 //            update(l,r+1,1,0,i);
 //        }
 //        if(k==1)
 //        {
 //            int loc=l;
 //            for(int i=0;i<26;++i)
 //            {
 //                if(cnt[i]) update(loc,loc+cnt[i],1,1,i);
 //                loc+=cnt[i];
 //            }
 //        }
 //        else
 //        {
 //            int loc=l;
 //            for(int i=25;i>=0;--i)
 //            {
 //                if(cnt[i]) update(loc,loc+cnt[i],1,1,i);
 //                loc+=cnt[i];
 //            }
 //        }
 //    }
 //    for(int i=1;i<=n;++i)
 //    {
 //        for(int j=0;j<26;++j)
 //        {
 //            if(query(i,i+1,1,j))
 //            {
 //                ans[i-1]='a'+j;
 //                break;
 //            }
 //        }
 //    }
 //    printf("%s\n",ans);
 //    return 0;
 //}
 int main()
 
 {
 
     int n,q;
 
     scanf("%d%d",&n,&q);
 
     scanf("%s",str);
 
     for(int i=;i<;i++)build(,n+,,i);
     //先按照原来的字符在数组里面的顺序对线段树进行填充
     int l,r,k;
 
     while(q--)
 
     {
 
         scanf("%d%d%d",&l,&r,&k);
 
         for(int i=;i<;i++)
 
         {
 
             cnt[i]=query(l,r+,,i);
             //找出来这个被要求的区间内有多少这个字母
             update(l,r+,,,i);
             //再把这个区间全部初始化为0
         }
         //判断一下是让顺序还是逆序，如果是按顺序排，那就让填充的时候字母正着填充
         if(k==)
 
         {
 
             int loc=l;
 
             for(int i=;i<;i++)
 
             {
 
                 if(cnt[i]>)update(loc,loc+cnt[i],,,i);
 
                 loc+=cnt[i];
 
             }
 
         }
 
         else
 
         {
 
             int loc=l;
 
             for(int i=;i>=;i--)
 
             {
 
                 if(cnt[i]>)update(loc,loc+cnt[i],,,i);
 
                 loc+=cnt[i];
 
             }
 
         }
 
     }
     //这个就相当于一个位置一个位置的查询
     for(int i=;i<=n;i++)
 
         for(int j=;j<;j++)
 
             if(query(i,i+,,j))
 
             {
 
                 ans[i-]='a'+j;
 
                 break;
 
             }
 
     printf("%s\n",ans);
 
     return ;
 
 }