【BZOJ 4662】 4662: Snow (线段树+并查集)

4662: Snow

Time Limit: 40 Sec  Memory Limit: 256 MB
Submit: 136  Solved: 47

Description

2333年的某一天，临冬突降大雪，主干道已经被雪覆盖不能使用。城

主 囧·雪 决定要对主干道进行一次清扫。

临冬城的主干道可以看为一条数轴。囧·雪 一共找来了n个清理工，第

i个清理工的工作范围为[li,ri]，也就是说这个清理工会把[li,ri]这一

段主干道清理干净(当然已经被清理过的部分就被忽略了)。当然有可能主

干道不能全部被清理干净，不过这也没啥关系。

虽然 囧·雪 啥都不知道，但是他还是保证了不会出现某一个清理工的

工作范围被另一个清理工完全包含的情况(不然就太蠢了)。

作为临冬城主，囧·雪 给出了如下的清扫方案：

在每一天开始的时候，每一个还没有工作过的清理工会观察自己工作

范围内的道路，并且记下工作范围内此时还没有被清理的道路的长度(称

为这个清理工的工作长度)。然后 囧·雪 会从中选择一个工作长度最小的

清理工(如果两个清理工工作长度相同，那么就选择编号小的清理工)。然

后被选择的这个清理工会清理自己的工作范围内的道路。为了方便检查工

作质量，囧·雪 希望每一天只有一个清理工在工作。

你要注意，清理工的工作长度是可能改变的，甚至有可能变成0。尽管

如此，这个清理工也还是会在某一天工作。

现在，囧·雪 想要知道每一天都是哪个清理工在工作？

Input

第一行两个整数t,n。分别表示主干道的长度(也就是说，主干道是数

轴上[1,t]的这一段)以及清理工的人数。

接下来n行，每行两个整数li,ri。意义如题。

n<=3*10^5, 1<=li<ri<=t<=10^9，保证输入的li严格递增

Output

输出n行，第i行表示第i天工作的清理工的编号。

Sample Input

15 4
1 6
3 7
6 11
10 14

Sample Output

2
1
3
4

HINT

Source

【分析】

　　其实这个也是线段树的经典了吧。

　　之前做过好几题，就是每次操作的时候都会有一个节点删掉以后彻底没用，这样即使暴力也是不会超时的，因为每个点只会用一次。

　　这里的这个点就是每个清洁工，我们只会询问他一次。

　　跳出清扫区间这个圈子，用清洁工来建线段树。

　　因为当你修改某段区间的时候，受影响的清洁工也是一个区间。

　　先离散化，然后暴力删去区间，用并查集快速跳去已经失效的区间，每个位置只会操作一次，是可以过的。

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 #define Maxn 300010
 #define INF 0x7fffffff

 int nl[Maxn],nr[Maxn],nn[Maxn*];

 struct node
 {
     int l,r,lc,rc,mn,lazy;
     int id;
 }tr[Maxn*];

 int rt[Maxn*];
 int rtt(int x)
 {
     if(rt[x]!=x) rt[x]=rtt(rt[x]);
     return rt[x];
 }

 int len=;
 int build(int l,int r)
 {
     int x=++len;
     tr[x].l=l;tr[x].r=r;
     if(l!=r)
     {
         int mid=(l+r)>>;
         tr[x].lc=build(l,mid);
         tr[x].rc=build(mid+,r);
         tr[x].lazy=;
         int lc=tr[x].lc,rc=tr[x].rc;
         if(tr[lc].mn<=tr[rc].mn) tr[x].mn=tr[lc].mn,tr[x].id=tr[lc].id;
         else tr[x].mn=tr[rc].mn,tr[x].id=tr[rc].id;
     }
     else tr[x].lc=tr[x].rc=,tr[x].mn=nn[nr[l]]-nn[nl[l]],tr[x].id=l;
     return x;
 }

 void upd(int x)
 {
     if(tr[x].l==tr[x].r) return;
     int lc=tr[x].lc,rc=tr[x].rc;
     if(tr[lc].mn!=INF) tr[lc].mn-=tr[x].lazy;
     if(tr[rc].mn!=INF) tr[rc].mn-=tr[x].lazy;
     tr[lc].lazy+=tr[x].lazy;
     tr[rc].lazy+=tr[x].lazy;
     tr[x].lazy=;
 }

 void change(int x,int y,int p)
 {
     if(tr[x].mn==INF) return;
     int mid=(tr[x].l+tr[x].r)>>,lc=tr[x].lc,rc=tr[x].rc;
     if(p)
     {
         if(nl[tr[x].l]<=y&&y<nr[tr[x].l]&&nl[tr[x].r]<=y&&y<nr[tr[x].r])
         {
             tr[x].lazy+=nn[y+]-nn[y];
             tr[x].mn-=nn[y+]-nn[y];
             return;
         }
         if(tr[x].l==tr[x].r) return;
         upd(x);
         if(y<nr[mid]) change(lc,y,p);
         if(nl[mid+]<=y) change(rc,y,p);
     }
     else
     {
         if(tr[x].l==tr[x].r)
         {
             tr[x].mn=INF;
             return;
         }
         upd(x);
         if(y<=mid) change(tr[x].lc,y,p);
         else change(tr[x].rc,y,p);
     }
     if(tr[lc].mn<=tr[rc].mn) tr[x].mn=tr[lc].mn,tr[x].id=tr[lc].id;
     else tr[x].mn=tr[rc].mn,tr[x].id=tr[rc].id;
 }

 struct nnode{int x,id;}t[Maxn*];
 bool cmp(nnode x,nnode y) {return x.x<y.x;}

 int main()
 {
     int mx,n;
     scanf("%d%d",&mx,&n);
     for(int i=;i<=n;i++) {scanf("%d%d",&nl[i],&nr[i]);
                       t[i*-].x=nl[i];t[i*-].id=i;t[i*].x=nr[i];t[i*].id=-i;}
     sort(t+,t++*n,cmp);
     mx=;nl[t[].id]=;nn[]=t[].x;
     for(int i=;i<=*n;i++)
     {
         if(t[i].x!=t[i-].x) mx++,nn[mx]=t[i].x;
         if(t[i].id>) nl[t[i].id]=mx;
         else nr[-t[i].id]=mx;
     }
     build(,n);
     for(int i=;i<=mx;i++) rt[i]=i;
     for(int i=;i<=n;i++)
     {
         int x=tr[].id;
         printf("%d\n",x);
         change(,x,);
         int st=rtt(nl[x]);
         for(int j=st;j<nr[x];)
         {
             change(,j,);
             rt[j]=rtt(j+);
             j=rt[j];
         }
     }
     return ;
 }

2017-03-27 09:29:36