【xsy2194】Philosopher set+线段树合并

题目大意：给你一个长度为$n$的序列，有$m$次操作，每次操作是以下两种之一：

对某个区间内的数按照升序/降序排序，询问某个区间内数的积在十进制下首位数字是多少。

数据范围：$n,m≤2\times 10^5$ 序列内数字均不大于$n$。

我们先考虑下如何实现查询首位数字

我们发现如果直接乘的话精度损失实在太大，我们考虑把所有读入的数字全部转成对数，直接加起来。

设某个区间内对数和为$x$，那么该区间内数的积的首位为$\lfloor 10^{x-\lfloor x\rfloor} \rfloor$。

下面考虑如何做排序操作

我们先种一堆的线段树，满足每一棵线段树维护的是一个已经按照升序/降序排序好的区间（内层线段树存储该区间内放了值为哪些的数）

我们对某个区间进行排序的时候，我们要取出若干个线段树，满足这些线段树构成的区间恰好为需要排序的区间。

然后我们通过线段树合并将这些区间合并为一个区间即可，最后打上这个区间的升序/降序标记

然而有些线段树被我们需要操作的区间部分包含。

这种情况下就需要把这棵线段树从中间某个位置开始拆开。

考虑到一棵线段树所代表的区间内的数都是排序好的，我们可以根据升序/降序标记来拆开这棵线段树。

每一棵线段树的根我们可以开一个$set$来存储，每一棵线段树内的对数和我们可以单独打在一个树状数组上。

在查询答案的时候，我们按照上面做排序的方法，拆出若干棵线段树，然后直接在线段树上查询即可。

时间复杂度：$O(n\log^2\ n)$

 #include<bits/stdc++.h>
 #define D long double
 #define M (1<<18)
 #define lowbit(x) (x&(-x))
 #define N 20000005
 #define S set<node>::iterator
 #define eps (1e-8)
 using namespace std;

 int n,m; D c[M]={}; void add(int x,D k){for(int i=x;i<=n;i+=lowbit(i)) c[i]+=k;}
 D query(int x){D k=; for(int i=x;i;i-=lowbit(i)) k+=c[i]; return k;}
 int num[M]={}; D val[M]={};

 struct node{
     int l,r,rt,op;
     node(int ll=,int rr=,int RT=,int OP=){l=ll; r=rr; rt=RT; op=OP;}
     friend bool operator <(node a,node b){return a.l<b.l;}
 };set<node> s;

 int lc[N]={},rc[N]={},cnt[N]={},use=; D sum[N]={};
 void pushup(int x){
     cnt[x]=cnt[lc[x]]+cnt[rc[x]];
     sum[x]=sum[lc[x]]+sum[rc[x]];
 }
 int merge(int x,int y){
     if(!x||!y) return x|y;
     lc[x]=merge(lc[x],lc[y]);
     rc[x]=merge(rc[x],rc[y]);
     cnt[x]=cnt[x]+cnt[y];
     sum[x]=sum[x]+sum[y];
     return x;
 }

 S Ins(node x){add(x.l,sum[x.rt]);return s.insert(x).first;}
 void Del(S it){add(it->l,-sum[it->rt]);s.erase(it);}

 void split(int x,int &rt1,int &rt2,int l,int r,int k){
     rt1=++use; rt2=++use;
     if(l==r){
         cnt[rt1]=k; sum[rt1]=val[l]*k;
         cnt[rt2]=cnt[x]-cnt[rt1];
         sum[rt2]=sum[x]-sum[rt1];
         return;
     }
     int mid=(l+r)>>;
     if(cnt[lc[x]]>=k){
         rc[rt2]=rc[x];
         split(lc[x],lc[rt1],lc[rt2],l,mid,k);
     }else{
         lc[rt1]=lc[x];
         split(rc[x],rc[rt1],rc[rt2],mid+,r,k-cnt[lc[x]]);
     }
     pushup(rt1); pushup(rt2);
 }
 S split(int x){
     if(x>n) return s.end();
     S it=s.upper_bound(node(x,,,)); it--;
     node hh=*it; if(hh.l==x) return it;
     int rt1,rt2;
     if(!hh.op) split(hh.rt,rt1,rt2,,n,x-hh.l);
     else split(hh.rt,rt2,rt1,,n,hh.r-x+);
     Del(it);
     Ins(node(hh.l,x-,rt1,hh.op));
     return Ins(node(x,hh.r,rt2,hh.op));
 }

 void updata(int l,int r,int op){
     S L=split(l); split(r+); int rt=;
     for(S it=L;it!=s.end()&&(it->l)<=r;Del(it++)){
         rt=merge(rt,it->rt);
     }
     Ins(node(l,r,rt,op));
 }
 int calc(int l,int r){
     S L=split(l),R=split(r+); R--;
     D ans=query(R->r)-query(L->l-);
     D out=pow(,ans-floorl(ans)+eps);
     return floorl(out);
 }

 void build(int &x,int l,int r,int k){
     x=++use; cnt[x]++; sum[x]+=val[k];
     if(l==r) return; int mid=(l+r)>>;
     if(k<=mid) build(lc[x],l,mid,k);
     else build(rc[x],mid+,r,k);
 }

 int main(){
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++) scanf("%d",num+i);
     for(int i=;i<=n;i++) val[i]=log10(i);
     for(int i=;i<=n;i++){
         int now; build(now,,n,num[i]);
         Ins(node(i,i,now,));
     }
     while(m--){
         int op,l,r; scanf("%d%d%d",&op,&l,&r);
         if(op==) printf("%d\n",calc(l,r));
         else{
             scanf("%d",&op); op^=;
             updata(l,r,op);
         }
     }
 }