Codeforces 899F Letters Removing 线段树/树状数组

虽然每次给一个区间，但是可以看作在区间内进行数个点操作，同样数列下标是动态变化的，如果我们将每个字符出现看作1，被删除看作0，则通过统计前缀和就能轻松计算出两个端点的位置了！这正是经典的树状数组操作

需要注意的是，即使每次找到了两个端点，如果只是朴素总左到右遍历会TLE，所以可以给每个字符开一个set，每个set储存字符出现的位置。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <map>
 #include <set>
 #include <vector>
 #include <algorithm>
 #pragma warning ( disable : 4996 )
 using namespace std;

 int Max( int a, int b ) { return a>b?a:b; }
 int Min( int a, int b ) { return a>b?b:a; }
 int lowbit( int x )        { return x&-x; }

 const int inf = 0x3f3f3f3f;
 const int maxn = 2e5+;

 set<int> pos[];
 set<int>::iterator it, it2;
 char str[maxn];
 int istr[maxn];
 bool isdel[maxn];

 int len, q;

 int getI( char c )
 {
     if( c >= 'a' && c <= 'z' ) return c-'a';
     if( c >= 'A' && c <= 'Z' ) return c-'A'+;
     if( c >= '' && c <= '' ) return c-''+;
 }

 int sum( int x )
 {
     int ret = ;
     while( x >  )
         {    ret += istr[x]; x -= lowbit(x); }
     return ret;
 }

 void add( int x, int d )
 {
     while( x <= len )
         { istr[x] += d; x += lowbit(x); }
 }

 int find( int s )
 {
     int mid, lhs = , rhs = len;
     int tmp;
     while ( lhs <= rhs )
     {
         mid = (lhs+rhs)>>;
         tmp = sum(mid);
         if ( tmp >= s ) rhs = mid-;
         else lhs = mid+;
     }
     return lhs;
 }

 void change( int l, int r, char c )
 {
     int p = getI(c);
     it = pos[p].lower_bound(l);
     while ( it!=pos[p].end() && *it<=r )
     {
         isdel[(*it)] = true;
         add((*it), -);
         it2 = it; it++;
         pos[p].erase(it2);
     }
 }

 int main()
 {
     cin >> len >> q;
     scanf("%s", str+);

     for ( int i = ; i <= len; i++ )
     {
         add(i,);
         int p = getI(str[i]);
         pos[p].insert(i);
     }

     int x, y;
     char c;
     for ( int i = ; i <= q; i++ )
     {
         scanf( "%d %d %c", &x, &y, &c );
         x = find(x); y = find(y);
         change( x, y, c );
     }

     for( int i = ; i <= len; i++ )
         if( !isdel[i] )
             printf( "%c", str[i] );

     printf("\n");
     return ;
 }

我们看到区间操作，自然就会想到线段树，但是数列下标是动态变换的，乍一看似乎线段树就没有用武之地了。实际仔细想想，线段树也可以动态统计从哪个区间开始操作，相比普通线段树只是在每次操作前要计算新的下标到哪了，实际上每个节点管辖的范围是始终不变的，变的只是范围内字符的个数size，每次操作前通过这个size找到对应的左端点和右端点就行了。

 //线段树
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <map>
 #include <vector>
 #include <algorithm>
 #pragma warning ( disable : 4996 )
 using namespace std;

 int Max( int a, int b ) { return a>b?a:b; }
 int Min( int a, int b ) { return a>b?b:a; }

 const int inf = 0x3f3f3f3f;
 const int maxn = 2e5+;

 struct tree {
     int size, lhs, rhs;
     int clu[];
 }t[maxn<<];
 char str[maxn];

 int getI( char c )
 {
     if( c >= 'a' && c <= 'z' ) return c-'a';
     if( c >= 'A' && c <= 'Z' ) return c-'A'+;
     if( c >= '' && c <= '' ) return c-''+;
 }

 char getC( int i )
 {
     if( i >=  && i <=  )  return 'a'+i;
     if( i >=  && i <=  ) return 'A'+i-;
     if( i >=  && i <=  ) return ''+i-;
 }

 void pushUp( int index )
 {
     t[index].size = t[index<<].size + t[index<<|].size;
     for ( int i = ; i < ; i++ )
         t[index].clu[i] = t[index<<].clu[i] + t[index<<|].clu[i];
 }

 void build( int l, int r, int index )
 {
     t[index].lhs = l; t[index].rhs = r;
     if( l == r )
         { t[index].size = ; t[index].clu[getI(str[l-])] = ; return; }
     int mid = (l+r)>>;
     build(l, mid, index<<);
     build(mid+, r, index<<|);
     pushUp(index);
 }

 int find( int index, int x )
 {
     int l = t[index].lhs, r = t[index].rhs;
     if( l == r ) return l;
     if( t[index<<].size >= x ) return find( index<<, x );
     else return find( index<<|, x-t[index<<].size );
 }

 void change( int index, int l, int r, int x )
 {
     int L = t[index].lhs, R = t[index].rhs;
     if ( r < L || l > R ) return;
     if ( !t[index].clu[x] ) return;
     if ( L == R ) { t[index].size--; t[index].clu[x]--; return; }
     change( index<<, l, r, x );
     change( index<<|, l, r, x );
     t[index].size = t[index<<].size + t[index<<|].size;
     t[index].clu[x] = t[index<<].clu[x] + t[index<<|].clu[x];
 }

 void print( int i )
 {
     int L=t[i].lhs,R=t[i].rhs;
     if ( L==R )
     {
         for ( int j = ; j < ; j++ )
             if ( t[i].clu[j] ) printf("%c",getC(j));
         return;
     }
     print(i<<);
     print(i<<|);

 }

 int main()
 {
     int len, q;
     cin >> len >> q;
     scanf("%s", str);
     build(, len, );

     int x, y;
     char c;
     for ( int i = ; i <= q; i++ )
     {
         scanf( "%d %d %c", &x, &y, &c );
         int l = find( , x );
         int r = find( , y );
         change( , l, r, getI(c) );
     }
     print();
     printf("\n");
     return ;
 }