Runtime: 340 ms (Top 55.43%) | Memory: 310.90 MB (Top 5.43%)

Author: AnasImloul

scripts/algorithms/H/Handling Sum Queries After Update/Handling Sum Queries After Update.cpp

@@ -1,70 +1,126 @@
-typedef long long ll;
+// Runtime: 340 ms (Top 55.43%) | Memory: 310.90 MB (Top 5.43%)
+
 class Solution {
 public:
-    static const ll maxn=1e5+6;
-    ll seg[maxn<<2];
-    bool lzy[maxn<<2];
-    void seg_init(int cur,int l,int r,vector<int> &nums)
+    typedef long long ll;
+    vector<ll> a, tree, lazy;
+
+    void build(int node,int start,int end)
     {
-        if(l+1==r)
+        if(start == end)
         {
-            seg[cur]=nums[l];
-            lzy[cur]=0;
+            tree[node] = a[start];
             return;
         }
-        int mid=(l+r)>>1;
-        seg_init(cur<<1,l,mid,nums);
-        seg_init(cur<<1|1,mid,r,nums);
-        seg[cur]=seg[cur<<1]+seg[cur<<1|1];
-        lzy[cur]=0;
-        return;
+
+        int mid = (start + end) / 2;
+        build(2*node,start,mid);
+        build(2*node+1,mid+1,end);
+
+        tree[node] = tree[2*node] + tree[2*node+1];
     }
-    void pushdown(int cur,int l,int r)
+
+    ll query(int node,int start,int end,int l,int r)
     {
-        if(lzy[cur])
+        if(lazy[node]%2==1)
         {
-            lzy[cur]^=1;
-            int mid=(l+r)>>1;
-            lzy[cur<<1]^=1;
-            lzy[cur<<1|1]^=1;
-            seg[cur<<1]=mid-l-seg[cur<<1];
-            seg[cur<<1|1]=r-mid-seg[cur<<1|1];
+            int k = lazy[node];
+          
+            lazy[node] = 0;               
+            tree[node] =  (end - start + 1) - tree[node]; 
+
+            if(start!=end) 
+            {
+                lazy[2*node] += k ;
+                lazy[2*node+1] += k;
+            }
         }
-        return;
+
+        if(start>r || end<l)
+        return 0;
+
+        if(start>=l && end<=r)
+        return tree[node];
+
+        ll mid = (start + end) / 2;
+
+        ll left = query(2*node,start,mid,l,r);
+        ll right = query(2*node+1,mid+1,end,l,r);
+        return left + right;
     }
-    void update(int cur,int l,int r,int tl,int tr)
+
+    void update(int node,int start,int end,int l,int r,int val)
     {
-        if(tl>=r||tr<=l)return;
-        if(tl<=l&&r<=tr)
+        if(lazy[node]%2==1)
         {
-            seg[cur]=r-l-seg[cur];
-            lzy[cur]^=1;
-            return;
+            int k = lazy[node];
+            lazy[node] = 0;
+            tree[node]  =(end - start + 1)  - tree[node] ;
+
+            if(start!=end)
+            {
+                lazy[2*node] += k ;
+                lazy[2*node+1] += k;
+            }
         }
-        pushdown(cur,l,r);
-        int mid=(l+r)>>1;
-        update(cur<<1,l,mid,tl,tr);
-        update(cur<<1|1,mid,r,tl,tr);
-        seg[cur]=seg[cur<<1]+seg[cur<<1|1];
+        
+
+        if(start>r || end<l)
         return;
-    }
-    vector<long long> handleQuery(vector<int>& nums1, vector<int>& nums2, vector<vector<int>>& queries) 
-    {
-        int n=nums1.size();
-        seg_init(1,0,n,nums1);
-        ll val=0;
-        for(auto &x:nums2)val+=x;
-        vector<ll>res;
-        for(auto &x:queries)
+
+        if(start>=l && end<=r)
         {
-            if(x[0]==1)
+            int k = (end - start + 1)  - tree[node];
+            tree[node] = k;
+
+            if(start!=end)  
             {
-                update(1,0,n,x[1],x[2]+1);
-            }else if(x[0]==2)
-            {
-                val+=seg[1]*x[1];
-            }else res.push_back(val);
+                lazy[2*node] += val;
+                lazy[2*node+1] += val;
+            }
+
+            return;
+        }
+
+        int mid = (start + end) / 2;
+
+        update(2*node,start,mid,l,r,val);
+        update(2*node+1,mid+1,end,l,r,val);
+
+        tree[node] = tree[2*node+1] + tree[2*node];
+    }
+
+    vector<long long> handleQuery(vector<int>& nums1, vector<int>& nums2, vector<vector<int>>& queries) {
+        ll sum2 = 0;
+        int nn = 100005;
+        a.resize(nn,0);
+        tree.resize(4*nn,0);
+        lazy.resize(4*nn,0);
+        
+        int n = nums1.size();
+        for(auto &i:nums2){
+            sum2+=i;
+        }
+        
+        for(int i = 0;i<n;i++){
+            a[i+1] = nums1[i];
+        }
+        vector<ll>ans;
+        build(1,1,n);
+        for(auto &i:queries){
+            if(i[0]==1){
+                update(1,1,n,i[1]+1,i[2]+1,1);
+            }
+            else if(i[0]==2){
+                ll p = i[1];
+                sum2+= p*query(1,1,n,1,n);
+            }
+            else if(i[0]==3){
+                ans.push_back(sum2);
+            }
         }
-        return res;
+        
+        return ans;
+        
     }
-};
+};