XTUOJ 1238 Segment Tree

Segment Tree

Accepted : 3 Submit : 21
Time Limit : 9000 MS Memory Limit : 65536 KB

Problem Description:

A contest is not integrity without problems about data structure.

There is an array a[1],a[2],…,a[n]. And q questions of the following 4 types:
1 l r c - Update a[k] with a[k]+c for all l≤k≤r
2 l r c - Update a[k] with min{a[k],c} for all l≤k≤r;
3 l r c - Update a[k] with max{a[k],c} for all l≤k≤r;
4 l r - Ask for min{a[k]:l≤k≤r} and max{a[k]:l≤k≤r}.

Input

The first line contains a integer T(no more than 5) which represents the number of test cases.

For each test case, the first line contains 2 integers n,q (1≤n,q≤200000).

The second line contains n integers a1,a2,…,an which indicates the initial values of the array (|ai|≤).

Each of the following q lines contains an integer t which denotes the type of i-th question. If t=1,2,3, 3 integers l,r,c follows. If t=4, 2 integers l,r follows. (1≤ti≤4,1≤li≤ri≤n)

If t=1, |ci|≤2000;

If t=2,3, |ci|≤10^9.

Output

For each question of type 4, output two integers denote the minimum and the maximum.

Sample Input

1
1 1
1
4 1 1

Sample Output

1 1

解题：如其名，线段树！关键在于如何解决矛盾，既要相加，又要进行区间重置？那么这样搞，如何进行lazy呢？只要设置一个重置标志就好了。

BB is cheap!

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct node {
     int lt,rt,theMin,theMax,add,lazy;
     bool reset;
 } tree[maxn<<];
 void pushup(int v) {
     tree[v].theMax = max(tree[v<<].theMax,tree[v<<|].theMax);
     tree[v].theMin = min(tree[v<<].theMin,tree[v<<|].theMin);
 }
 void pushdown(int v) {
     if(tree[v].reset){
         tree[v].reset = false;
         tree[v<<].reset = tree[v<<|].reset = true;
         tree[v<<].lazy = tree[v<<|].lazy = tree[v].lazy;
         tree[v<<].theMin = tree[v<<].theMax = tree[v].lazy;
         tree[v<<|].theMin = tree[v<<|].theMax = tree[v].lazy;
         tree[v<<].add = tree[v<<|].add = ;
         //cout<<tree[v].lt<<" "<<tree[v].rt<<" "<<tree[v].lazy<<" nmb"<<endl;
     }
     if(tree[v].add){
         tree[v<<].add += tree[v].add;
         tree[v<<|].add += tree[v].add;
         tree[v<<].theMax += tree[v].add;
         tree[v<<].theMin += tree[v].add;
         tree[v<<|].theMax += tree[v].add;
         tree[v<<|].theMin += tree[v].add;
         tree[v].add = ;
     }
 }
 void build(int lt,int rt,int v) {
     tree[v].lt = lt;
     tree[v].rt = rt;
     tree[v].reset = false;
     tree[v].add = ;
     if(lt == rt) {
         scanf("%d",&tree[v].theMin);
         tree[v].theMax = tree[v].theMin;
         return;
     }
     int mid = (lt + rt)>>;
     build(lt,mid,v<<);
     build(mid+,rt,v<<|);
     pushup(v);
 }
 int queryMax(int lt,int rt,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt) return tree[v].theMax;
     pushdown(v);
     int theMax = INT_MIN;
     if(lt <= tree[v<<].rt) theMax = max(theMax,queryMax(lt,rt,v<<));
     if(rt >= tree[v<<|].lt) theMax = max(theMax,queryMax(lt,rt,v<<|));
     pushup(v);
     return theMax;
 }
 int queryMin(int lt,int rt,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt) return tree[v].theMin;
     pushdown(v);
     int theMin = INT_MAX;
     if(lt <= tree[v<<].rt) theMin = min(theMin,queryMin(lt,rt,v<<));
     if(rt >= tree[v<<|].lt) theMin = min(theMin,queryMin(lt,rt,v<<|));
     pushup(v);
     return theMin;
 }
 void add(int lt,int rt,int val,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt) {
         tree[v].add += val;
         tree[v].theMax += val;
         tree[v].theMin += val;
         return;
     }
     pushdown(v);
     if(lt <= tree[v<<].rt) add(lt,rt,val,v<<);
     if(rt >= tree[v<<|].lt) add(lt,rt,val,v<<|);
     pushup(v);
 }
 void updateMax(int lt,int rt,int val,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt && tree[v].theMax <= val) {
         tree[v].reset = true;
         tree[v].theMax = tree[v].theMin = val;
         tree[v].lazy = val;
         tree[v].add = ;
         return;
     }else if(lt <= tree[v].lt && rt >= tree[v].rt && val <= tree[v].theMin) return;
     pushdown(v);
     if(lt <= tree[v<<].rt) updateMax(lt,rt,val,v<<);
     if(rt >= tree[v<<|].lt) updateMax(lt,rt,val,v<<|);
     pushup(v);
 }
 void updateMin(int lt,int rt,int val,int v) {
     if(lt <= tree[v].lt && rt >= tree[v].rt && tree[v].theMin >= val){
         tree[v].add = ;
         tree[v].reset = true;
         tree[v].theMax = tree[v].theMin = val;
         tree[v].lazy = val;
         return;
     }else if(lt <= tree[v].lt && rt >= tree[v].rt  && tree[v].theMax <= val) return;
     pushdown(v);
     if(lt <= tree[v<<].rt) updateMin(lt,rt,val,v<<);
     if(rt >= tree[v<<|].lt) updateMin(lt,rt,val,v<<|);
     pushup(v);
 }
 int main() {
     int n,q,op,x,y,c,T;
     scanf("%d",&T);
     while(T--){
         scanf("%d %d",&n,&q);
         build(,n,);
         while(q--){
             scanf("%d%d%d",&op,&x,&y);
             switch(op){
                 case :scanf("%d",&c);add(x,y,c,);break;
                 case :scanf("%d",&c);updateMin(x,y,c,);break;
                 case :scanf("%d",&c);updateMax(x,y,c,);break;
                 case :printf("%d %d\n",queryMin(x,y,),queryMax(x,y,));break;
                 default:;
             }
         }
     }
     return ;
 }