loj 6029 "Yali training 2017 Day1" market

analysis

Plus interval, and the interval, the minimum interval, the interval divisible

answer

With properties similar range prescribing, in addition to once again go down, the number will be closer to the interval

When the number of sections in the close, they will reduce the number of equal, it is transformed into the interval minus

Code

  1 /*****************************
  2 User:Mandy.H.Y
  3 Language:c++
  4 Problem:market
  5 *****************************/
  6 //
  7 #include<bits/stdc++.h>
  8 #define lson l,mid,k << 1
  9 #define rson mid + 1,r,k << 1 | 1
 10 #define Max(x,y) ((x) > (y) ? (x) : (y))
 11 #define Min(x,y) ((x) < (y) ? (x) : (y))
 12 
 13 using namespace std;
 14 
 15 const int maxn = 1e5 + 5;
 16 
 17 int n,q;
 18 long long sum[maxn << 2];
 19 int mi[maxn << 2],ma[maxn << 2],lazy[maxn << 2];
 20 int L,R,C,D;
 21 
 22 template<class T>inline void read(T &x){
 23     x = 0;bool flag = 0;char ch = getchar();
 24     while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
 25     while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
 26     if(flag) x = -x;
 27 }
 28 
 29 template<class T>void putch(const T x){
 30     if(x > 9) putch(x / 10);
 31     putchar(x % 10 | 48);
 32 }
 33 
 34 template<class T>void put(const T x){
 35     if(x < 0) putchar('-'),putch(-x);
 36     else putch(x);
 37 }
 38 
 39 void file(){
 40     freopen("market.in","r",stdin);
 41     freopen("market.out","w",stdout);
 42 }
 43 
 44 void pushup(int k){
 45     int ls = k << 1;
 46     int rs = k << 1 | 1;
 47     sum[k] = sum[ls] + sum[rs];
 48     mi[k] = Min(mi[ls],mi[rs]);
 49     ma[k] = Max(ma[ls],ma[rs]);
 50 } 
 51 
 52 void buildtree(int l,int r,int k){
 53     if(l == r){
 54         read(mi[k]);
 55         sum[k] = ma[k] = mi[k];
 56         return ;
 57     }
 58     int mid = (l + r) >> 1;
 59     buildtree(lson);
 60     buildtree(rson);
 61     pushup(k);
 62 }
 63 
 64 void readdata(){
 65     read(n);read(q);
 66     buildtree(1,n,1);
 67 }
 68 
 69 void pushdown(int l,int r,int k){
 70     if(!lazy[k]) return;
 71     int ls = k << 1;
 72     int rs = ls | 1;
 73     int mid = (l + r) >> 1;
 74     sum[ls] += (long long)lazy[k] * (mid - l + 1);
 75     sum[rs] += (long long)lazy[k] * (r - mid);
 76     mi[ls] += lazy[k];ma[ls] += lazy[k]; 
 77     mi[rs] += lazy[k];ma[rs] += lazy[k]; 
 78     lazy[ls] += lazy[k];
 79     lazy[rs] += lazy[k];
 80     lazy[k] = 0;
 81 }
 82 
 83 void add(int l,int r,int k){
 84     if(L <= l && r <= R){
 85         sum[k] += (long long)C * (r - l + 1);
 86         mi[k] += C;
 87         ma[k] += C;
 88         lazy[k] += C;
 89         return;
 90     }
 91     pushdown(l,r,k);
 92     int MID = (L + R & lt) >> . 1 ;
 93      IF (L <= MID) the Add (LSON);
 94      IF (R & lt> MID) the Add (rson);
 95      a pushup (K);
 96  }
 97  
98  void div ( int L, int R & lt, int K) { // If the value of the maximum and minimum drop interval are the same, then the value of the drop interval as 
99      IF (L <= R & lt && L <= R & lt) {
 100          int TMP1 = mA [K] - ( int ) Floor (( Double ) mA [K] / ( Double ) D);
 101          int TMP2 = mi The [K] - (int)floor((double)mi[k]/(double)D);
102         if(tmp1 == tmp2){
103             sum[k] -= (long long)tmp1 * (r - l + 1);
104             mi[k] -= tmp1;
105             ma[k] -= tmp1;
106             lazy[k] -= tmp1;
107             return;
108         }
109     }
110     pushdown(l,r,k);
111     int mid =  (l + r) >> 1;
112     if(L <= mid) div(lson);
113     if(R > mid) div(rson);
114     pushup(k);    
115 }
116 
117 long long get_sum(int l,int r,int k){
118     if(L <= l && r <= R) return sum[k];
119     pushdown(l,r,k);
120     int mid =  (l + r) >> 1;
121     long long ans = 0;
122     if(L <= mid) ans += get_sum(lson);
123     if(R > mid) ans += get_sum(rson);
124     pushup(k);
125     return ans;
126 }
127 
128 int get_min(int l,int r,int k){
129     if(L <= l && r <= R) return mi[k];
130     pushdown(l,r,k);
131     int mid =  (l + r) >> 1;
132     int ans1 = 2e9 + 5;
133     int ans2 = 2e9 + 5;
134     if(L <= mid) ans1 =get_min (LSON);
 135      IF (R & lt> MID) ANS2 = get_min (rson);
 136      a pushup (K);
 137      return Min (ANS1, ANS2);
 138  }
 139  
140  void Work () {
 141 is      the while (Q - ) {
 142          int opt;
 143          Read (opt);
 144          Switch (opt) {
 145              Case  . 1 : {
 146                  Read (L); Read (R & lt); Read (C);
 147                  L ++, R & lt ++; // Note that given this question reference numeral from 0 
148                  the Add ( . 1 , n-,1);
149                 break;
150             }
151             case 2:{
152                 read(L);read(R);read(D);
153                 L++,R++;
154                 div(1,n,1);
155                 break;
156             }
157             case 3:{
158                 read(L);read(R);L++,R++;
159                 int ans = get_min(1,n,1);
160                 put(ans);puts("");
161                 break;
162             }
163             case 4:{
164                 read(L);read(R);
165                 L++,R++;
166                 long long ans = get_sum(1,n,1);
167                 put(ans);puts("");
168                 break;
169             }
170         }
171     }
172 }
173 
174 int main(){
175 //    file();
176     readdata();
177     work(); 
178     return 0;
179 }
View Code

 

Guess you like

Origin www.cnblogs.com/Mandy-H-Y/p/11506289.html