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

时间：2023-03-08 21:59:23

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

相关文章