Add tutorial for LOJ-1164 Horrible Queries #471

Author: Evan-CSE

1164/en.md

@@ -0,0 +1,130 @@
+# LOJ-1164: Horrible Queries
+
+## Prerequisite:
+1. Segment Tree
+2. Range Operation: Lazy Propagation
+
+## Problem at a glance:
+In this problem we are required to perform two kinds of operation.
+1. Update a range by a given `value`
+2. Find the total sum of given range
+
+## Approach
+Its clear that we can use `cumulative sum` to answer the second type of query. However, updating a range of values using this approach would have a time complexity of **O(n)**, which could lead to a **"Time Limit Exceeded" (TLE)** error for larger inputs. If you are already familiar with **segment tree** then you can start with segment tree. But unlike segment tree we are required to **update range** which may lead to **TLE** To solve this problem we can use a variation of **segment tree** called **lazy propagation** 
+
+## Lazy Propagation at a glance
+Lazy propagation is an optimization technique used with segment trees. If you are not familiar with segment trees, it is recommended to learn about them before proceeding.
+
+With lazy propagation, instead of updating a range instantly, we only mark the root node of that range for future updates. We maintain an extra array to keep track of which nodes need to be updated. Here's an illustration:
+
+<img src="lazyPropagationExample.jpg">
+
+Let's say we want to update the range [4:6]. The root node of this range is the 3rd node. Rather than updating all the nodes below [4:6] immediately, we simply mark the immediate children of the 3rd node with a value that should be added in the future. Our second array tracks this information for each node to determine if its child nodes should be updated or not. When we need to query or update the range again, we will update the specific node.
+
+You will have a better understanding of this concept as you read through the tutorial. It's a straightforward problem if you can understand both the segment tree and lazy propagation algorithms.
+
+### Code
+
+```
+#include<bits/stdc++.h>
+
+using namespace std;
+
+#define ll long long
+#define endl "\n"
+#define MAX 400010
+
+
+ll segSum[MAX], lazy[MAX];
+
+void clearAll() {
+    for (int i = 0; i < MAX; i++) {
+        segSum[i] = 0;
+        lazy[i] = 0;
+    }
+}
+
+
+void update(int node, ll leftTree, ll rightTree, ll left, ll right, ll value) {
+    int leftSide  = node * 2;
+    int rightSide = (node * 2) + 1;
+    if (lazy[node]) {
+        segSum[node] += ((rightTree - leftTree + 1) * lazy[node]);
+        if (leftTree != rightTree) {
+            lazy[leftSide]  += lazy[node];
+            lazy[rightSide] += lazy[node];
+        } 
+        lazy[node] = 0;
+    }
+    if (leftTree > right || rightTree < left) {
+        return;
+    }
+    if (leftTree >= left && rightTree <= right) {
+        segSum[node] += ((rightTree - leftTree + 1) * value);
+        if (leftTree != rightTree) {
+            lazy[leftSide]  += value;
+            lazy[rightSide] += value;
+        }
+        return;
+    }
+    int mid = (leftTree + rightTree) >> 1;
+    update(leftSide, leftTree, mid, left, right, value);
+    update(rightSide, mid + 1, rightTree, left, right, value);
+    segSum[node] = segSum[leftSide] + segSum[rightSide];
+}
+
+
+ll query(int node, ll lt, ll rt, ll l, ll r) {
+    int leftSide  = node * 2;
+    int rightSide = (node * 2) + 1;
+    if (lazy[node]) {
+        segSum[node] += ((rt - lt + 1) * lazy[node]);
+        if (lt != rt) {
+            lazy[leftSide]  += lazy[node];
+            lazy[rightSide] += lazy[node];
+        } 
+        lazy[node] = 0;
+    }
+    if (lt > r || rt < l) {
+        return 0;
+    }
+    if (l <= lt && rt <= r) {
+        return segSum[node];
+    }
+    int mid = (lt + rt) >> 1;
+    ll leftSum  = query(leftSide, lt, mid, l, r);
+    ll rightSum = query(rightSide, mid + 1, rt, l, r);
+    return leftSum + rightSum;   
+}
+
+
+int  main() {
+    int t, cs = 1;
+    cin >> t;
+    while (t--) {
+        int n,q;
+        cin >> n >> q;
+        clearAll();
+        cout <<"Case "<< cs++ << ":\n";
+        while(q--) {
+            int choice, left, right;
+            cin >> choice >> left >> right;
+            if (choice == 0) {
+                ll value;
+                cin >> value;
+                update(1, 0, n - 1, left, right, value);
+            }
+            else {
+                cout << query(1, 0, n - 1, left, right) <<endl;
+            }
+        }
+    }
+    return 0;
+}
+```
+## Resources:
+- [Segment Tree](https://cp-algorithms.com/data_structures/segment_tree.html)
+- [Lazy Propagation](https://www.topcoder.com/thrive/articles/range-operations-lazy-propagation)
+
+### Tutorial by:
+Profile Link: [Hasibur Rahman](https://lightoj.com/user/evan13)