HUST 1407（数据结构）

1407 - 郁闷的小J

小J是国家图书馆的一位图书管理员，他的工作是管理一个巨大的书架。虽然他很能吃苦耐劳，但是由于这个书架十分巨大，所以他的工作效率总是很低，以致他面临着被解雇的危险，这也正是他所郁闷的。

具体说来，书架由N个书位组成，编号从1到N。每个书位放着一本书，每本书有一个特定的编码。

小J的工作有两类：

1. 图书馆经常购置新书，而书架任意时刻都是满的，所以只得将某位置的书拿掉并换成新购的书。
2. 小J需要回答顾客的查询，顾客会询问某一段连续的书位中某一特定编码的书有多少本。

例如，共5个书位，开始时书位上的书编码为1，2，3，4，5

一位顾客询问书位1到书位3中编码为“2”的书共多少本，得到的回答为：1

一位顾客询问书位1到书位3中编码为“1”的书共多少本，得到的回答为：1

此时，图书馆购进一本编码为“1”的书，并将它放到2号书位。

一位顾客询问书位1到书位3中编码为“2”的书共多少本，得到的回答为：0

一位顾客询问书位1到书位3中编码为“1”的书共多少本，得到的回答为：2

……

你的任务是写一个程序来回答每个顾客的询问。

INPUT

第一行两个整数N，M，表示一共N个书位，M个操作。

接下来一行共N个整数数A1,A2…AN，Ai表示开始时位置i上的书的编码。

接下来M行，每行表示一次操作，每行开头一个字符

若字符为‘C’，表示图书馆购进新书，后接两个整数A(1<=A<=N)，P，表示这本书被放在位置A上，以及这本书的编码为P。

若字符为‘Q’，表示一个顾客的查询，后接三个整数A，B，K(1<=A<=B<=N)，表示查询从第A书位到第Ｂ书位（包含Ａ和Ｂ）中编码为Ｋ的书共多少本。

（1<=N,M<=100000，所有出现的书的编码为不大于2147483647的正数。）

OUTPUT

对每一个顾客的查询，输出一个整数，表示顾客所要查询的结果。

---

sl： 首先随便写了个 线段树套set的方法，不出预料的TLE .

然后又写了个线段树套SBT的写法  ，不能忍的TIE.

最后托人写了个二进制trie的方法  ，AC。但是本若菜不想写虽然很短。

继续yy,  发现用map 吧相同的数字的位置维护一下，这个可以用sbt，或是任何的数据结构都可以吧。然后就能过了。但是不想敲了，囧。

先贴上几份sb了的代码。AC代码随后补上。

正确代码可以参考：   http://vjudge.net/vjudge/problem/viewSource.action?id=2690221   （我就不贴了。。）

我的两份　：

+;
];
];
];
];
; lch[] = rch[] = sz[] = ; }
; }
 == sz[root]; }
); }
 + sz[lch[t]] + sz[rch[t]];
 + sz[lch[t]] + sz[rch[t]];
 == t)  == k)               }
     Type GetSuc(          == root)                   Type tmp = GetSuc(lch[t], k);
                       }
     Type GetKth(                  )          );
     }
               == t) ;
                   + GetRank(rch[t], k);
     }
               == t) ;
                   + GetSmaller(rch[t], k);
     }
               == t)                        }
               == t) {
             t = ++tot;
             lch[t] = rch[t] = ;
             sz[t]= ;
             key[t] = k;
                      }
         sz[t]++;
                           Maintain(t, k >= key[t]);
     }
               == t)                       t = rch[t];
             DeleteSmaller(t , key);
         }              DeleteSmaller(lch[t] , k);
             sz[t] =  + sz[lch[t]] + sz[rch[t]];
         }
     }
     Type Delete(         sz[t]--;
          == lch[t]) || (k > key[t] &&  == rch[t])) {
             Type tmp = key[t];
              == lch[t] ||  == rch[t]) {
                 t = lch[t] + rch[t];
             }                  key[t] = Delete(lch[t], key[t] + );
             }
                      }                                            }                               }
         }
     }
       };
 
 SBT<];
 inline  {
     ;
               +ch-      }
                sbt[o].InsertR(a[i]);
     }
          ;
     build(L,mid,o<<);
     build(mid+,R,o<<|);
 }
      sbt[o].Delete(a[pos]);
     sbt[o].InsertR(val);
          ;
     ,pos,val);
     ,R,o<<|,pos,val);
 }
               );
              }
     ;
     ;
     ,ls,rs,val);
     ,R,o<<|,ls,rs,val);
      }
 
      ];
          ) {
         ;i<=n;i++) {
             a[i]=read();
         }
 
         build(,n,);
         ;i<=m;i++) {
             scanf(             ]==                 ls=read(); rs=read(); val=read();
                 ,n,,ls,rs,val);
                 printf(             }
                              ls=read(); val=read();
                 Update(,n,,ls,val);
                 a[ls]=val;
             }
         }
     }
     ;
 }

+;
];
 inline  {
     ;
               +ch-      }
      hash[o].clear();
              hash[o].insert(a[i]);
     }
 
          ;
     build(L,mid,o<<);
     build(mid+,R,o<<|);
 }
      hash[o].erase(hash[o].find(a[pos]));
     hash[o].insert(val);
          ;
     ,pos,val);
     ,R,o<<|,pos,val);
 }
                    }
     ;
     ;
     ,ls,rs,val);
     ,R,o<<|,ls,rs,val);
      }
 
      ];
          scanf(     ;i<=n;i++) {
         a[i]=read();
     }
 
     build(,n,);
     ;i<=m;i++) {
         scanf(         ]==             ls=read(); rs=read(); val=read();
             ,n,,ls,rs,val);
             printf(         }
                      ls=read(); val=read();
             Update(,n,,ls,val);
             a[ls]=val;
         }
     }
 
     ;
 }