bzoj1178/luogu3626 会议中心 (倍增+STL::set)

贪心地，可以建出一棵树，每个区间对应一个点，它的父亲是它右边的、与它不相交的、右端点最小的区间。

为了方便，再加入一个[0,0]区间

于是就可以倍增来做出从某个区间开始，一直到某个右界，这之中最多能选多少区间

这样的话，可以从[0,0]区间，倍增做出第一问的答案

考虑第二问，我们需要尽量选编号小的区间，于是只要判断我们如果选了这个区间 还能不能选够那么多就可以了

而且前面已经选过的就钦定住了

开一个set来放下已经选过的区间，按左端点从小到大排序

为了方便，一开始先把[0,0]区间和[inf,inf]区间加进去。设当前区间是x

这样的话，只要找到前驱pre、后继nxt，判断pre、nxt是否和x相交，相交就不做了

然后看从pre到nxt能选几个、（pre到x）+（x到nxt）+1能选几个，看看是否相等，来判断选不选x

 #include<bits/stdc++.h>
 #define pa pair<int,int>
 #define CLR(a,x) memset(a,x,sizeof(a))
 using namespace std;
 typedef long long ll;
 const int maxn=2e5+,inf=1e9+;

 inline ll rd(){
     ll x=;char c=getchar();int neg=;
     while(c<''||c>''){if(c=='-') neg=-;c=getchar();}
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
     return x*neg;
 }

 struct Node{
     int l,r,i;
     Node (int a=,int b=,int c=){l=a,r=b,i=c;}
 }pos[maxn],pos2[maxn],pos3[maxn];
 bool operator < (Node a,Node b){return a.l<b.l;}
 int N,M;
 int ma[maxn*],fa[maxn][],cnt[maxn][];
 set<Node> st;
 bool flag[maxn];

 inline bool cmp(Node a,Node b){return a.l<b.l;}
 inline bool cmp2(Node a,Node b){return a.r<b.r;}

 inline int getst(int x,int bnd){
     int re=;
     for(int i=;i>=;i--){
         if(fa[x][i]&&pos2[fa[x][i]].r<bnd)
             re+=cnt[x][i],x=fa[x][i];
     }
     return re;
 }

 int main(){
     //freopen("","r",stdin);
     int i,j,k;
     N=rd();
     for(i=,j=;i<=N;i++){
         pos[i].l=rd(),pos[i].r=rd();pos[i].i=i;
     }
     memcpy(pos2,pos,sizeof(pos));
     memcpy(pos3,pos,sizeof(pos));
     sort(pos+,pos+N+,cmp);
     sort(pos3+,pos3+N+,cmp2);
     int mm=inf,mi=;
     for(i=N,j=N;i;i--){
         for(;pos[j].l>pos3[i].r;j--){
             if(pos[j].r<mm) mm=pos[j].r,mi=pos[j].i;
         }
         int x=pos3[i].i;
         fa[x][]=mi;cnt[x][]=;
         // printf("%d %d\n",x,fa[x][0]);
         for(k=;fa[x][k]&&fa[fa[x][k]][k];k++){
             fa[x][k+]=fa[fa[x][k]][k];
             cnt[x][k+]=cnt[x][k]+cnt[fa[x][k]][k];
         }
     }
     fa[N+][]=pos3[].i;cnt[N+][]=;
     for(k=;fa[N+][k]&&fa[fa[N+][k]][k];k++){
         fa[N+][k+]=fa[fa[N+][k]][k];
         cnt[N+][k+]=cnt[N+][k]+cnt[fa[N+][k]][k];
     }
     printf("%d\n",getst(N+,inf));

     st.insert(Node(,,N+));st.insert(Node(inf,inf,N+));
     for(i=;i<=N;i++){
         set<Node>::iterator it=st.lower_bound(pos2[i]);
         Node nxt=*it;
         Node pre=*(--it);
         if(nxt.l<=pos2[i].r||pre.r>=pos2[i].l) continue;
         int n1=getst(pre.i,pos2[i].l)+getst(i,nxt.l)+;
         int nn=getst(pre.i,nxt.l);
         // printf("%d %d %d %d %d\n",i,pre.i,nxt.i,nn,n1);
         if(n1<nn) continue;
         flag[i]=;
         st.insert(pos2[i]);
     }
     for(i=;i<=N;i++) if(flag[i]) printf("%d ",i);
     return ;
 }