# Codeforce 915e (dynamic open point of line tree)

Keywords: Programming

Alex graduated from high school. He is now a freshman. Although he studied programming, he still had to take physical education, which was a complete surprise to him. It's almost the end of the term, but unfortunately Alex's PE credits are still zero!
Alex doesn't want to be fired. He wants to know how many working days are left until the end of the term so that he can take sports credits on those days. But calculating workdays here is not easy:
There are still n days (from 1 to n numbers) between now and the end of the semester. They are working days at the beginning. Next, the school staff will issue q instructions in turn. Each instruction can be described by three parameters l,r,k:
If k=1, all days from l to r (including endpoints) become non working days.
If k=2, all days from l to r (including endpoints) become working days.
Help Alex count the remaining working days after each instruction is issued
(1≤n≤10^9,1≤q≤3*10^5)

code:

```#include <map>
#include <stack>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
const int siz=15000005;
int n,m,id;
int ll[siz],rr[siz],sum[siz],lazy[siz];
void pushdown(int l,int r,int rt){
if(lazy[rt]!=-1){
int m=(l+r)>>1;
if(l!=r){                               //If it is not a leaf node, it needs to open a left node or a right node
if(ll[rt]==0) ll[rt]=++id;          //So as to pass on the mark
if(rr[rt]==0) rr[rt]=++id;
lazy[ll[rt]]=lazy[rt];
lazy[rr[rt]]=lazy[rt];
sum[ll[rt]]=(m-l+1)*lazy[rt];
sum[rr[rt]]=(r-m)*lazy[rt];
}
lazy[rt]=-1;
}
}
void change(int L,int R,int p,int l,int r,int &rt){
if(!rt) rt=++id;                            //Dynamic open point is when to use and when to open point
if(L<=l&&r<=R){
lazy[rt]=p;
sum[rt]=p*(r-l+1);
return;
}
pushdown(l,r,rt);
int m=(l+r)>>1;
if(L<=m)
change(L,R,p,l,m,ll[rt]);
if(R>m)
change(L,R,p,m+1,r,rr[rt]);
sum[rt]=sum[ll[rt]]+sum[rr[rt]];
}
int main(){                                     //Because n is very large, it can be directly opened dynamically
int i,j,x,y,z,rt;                           //Complexity O(qlogn), complexity may not be direct
while(scanf("%d%d",&n,&m)!=EOF){            //Discrete O(qlogq) is excellent, but it is relatively simple to implement
id=rt=0;
memset(ll,0,sizeof(ll));
memset(rr,0,sizeof(rr));
memset(sum,0,sizeof(sum));
memset(lazy,-1,sizeof(lazy));
for(i=1;i<=m;i++){
scanf("%d%d%d",&x,&y,&z);
if(z==1)
change(x,y,1,1,n,rt);
else
change(x,y,0,1,n,rt);
printf("%d\n",n-sum[1]);
}
}
return 0;
}
/*
10
3
2 3 1
1 5 1
4 6 1
*/
```

Posted by farkewie on Mon, 04 May 2020 11:45:06 -0700