Mid-Autumn Full Moon Night

This problem describes a classic application of a specialized segment tree technique, often referred to as "segment tree beats" or "segment tree with range minimum/maximum updates." The core idea is to efficiently handle updates of the form: "for all elements $A_i$ in range $[L, R]$, set $A_i = \min(A_i, X)$." This update has the property that elements only decrease, and once an element is less than or equal to $X$, it won't be affected by *this specific* update anymore. Here's a detailed breakdown of the approach: **1. Key Observation and Node Properties** The crucial observation is that an individual element $A_i$ can only be updated (i.e., decreased) a logarithmic number of times before it reaches a final value. This is because each update strictly decreases its value, and values are bounded (e.g., by 0). To exploit this, each node in our segment tree, representing a range `[l, r]`, needs to store specific information: * **`sum`**: The sum of all elements in its range. (For range sum queries) * **`mx`**: The maximum value in its range. * **`mn`**: The minimum value in its range. * **`cnt_mx`**: The count of elements in its range that have the value `mx`. * **`second_mx`**: The second maximum value in its range. This is *strictly less* than `mx`. If all elements are the same, or there's only one element, this can be represented as $-\infty$ or a very small number. **2. Lazy Propagation (Tag)** We use a lazy tag for range updates. Let's call it `lazy_val`. If `lazy_val` is present and active on a node, it means all elements in that node's range that are greater than `lazy_val` should be capped at `lazy_val`. **3. `push_down(node)` Function** This function applies the `lazy_val` of the current `node` to its children. * If `node.lazy_val` is active: * Apply the update (using a helper function like `apply_update_to_node`) to `node.left_child` and `node.right_child` with `node.lazy_val`. * Clear `node.lazy_val` for the current node. **4. `apply_update_to_node(node, val)` Function** This function updates a single node (or a segment represented by a node) as if all values greater than `val` become `val`. This is called when we can update an entire node's range in O(1) time without recursing. * **Precondition:** `node.mx > val` (otherwise no change is needed). * **Update `sum`**: `node.sum -= node.cnt_mx * (node.mx - val)` (only the maximum elements are reduced). * **Update `mx`**: `node.mx = val`. * **Update `lazy_val`**: `node.lazy_val = val`. This will be propagated later. **5. `pull_up(node)` Function** After recursively updating children, this function recalculates the current node's properties based on its children: * `node.sum = node.left_child.sum + node.right_child.sum` * `node.mn = min(node.left_child.mn, node.right_child.mn)` * `node.mx`, `node.second_mx`, `node.cnt_mx` are computed by carefully merging the children's `mx`, `second_mx`, and `cnt_mx`. * If `left_child.mx == right_child.mx`: `node.mx = left_child.mx`, `node.cnt_mx = left_child.cnt_mx + right_child.cnt_mx`. `node.second_mx` is `max(left_child.second_mx, right_child.second_mx)`. * If `left_child.mx > right_child.mx`: `node.mx = left_child.mx`, `node.cnt_mx = left_child.cnt_mx`. `node.second_mx` is `max(left_child.second_mx, right_child.mx)`. * If `left_child.mx < right_child.mx`: `node.mx = right_child.mx`, `node.cnt_mx = right_child.cnt_mx`. `node.second_mx` is `max(right_child.second_mx, left_child.mx)`. **6. `update_range(node, query_L, query_R, X)` Function** This is the main function for performing the range "min" update. `node` covers `[node.l, node.r]`. We want to update `[query_L, query_R]` with value `X`. 1. **Base Cases:** * **No Overlap:** If `[node.l, node.r]` does not intersect `[query_L, query_R]`, do nothing. * **Node Max <= X:** If `node.mx <= X`, no element in this range will be affected by the update (all are already less than or equal to `X`). Do nothing. * **Full Overlap & `node.second_mx < X`:** If `[node.l, node.r]` is fully contained within `[query_L, query_R]`, AND importantly, `node.second_mx < X`. This is the "beats" part. It means only the elements equal to `node.mx` are greater than `X`. All other elements (`second_mx` or less) are already less than or equal to `X`. In this situation, we can directly update the current node: `apply_update_to_node(node, X)`. This is an O(1) operation on the node, avoiding recursion. 2. **Recursive Step:** * If none of the base cases apply, `push_down(node)` to apply any pending lazy tags to children. * Recurse on left child: `update_range(node.left_child, query_L, query_R, X)` * Recurse on right child: `update_range(node.right_child, query_L, query_R, X)` * After children are updated, `pull_up(node)` to aggregate their results. **7. `query_sum(node, query_L, query_R)` Function** This is a standard segment tree range sum query. 1. **Base Cases:** * **No Overlap:** If `[node.l, node.r]` does not intersect `[query_L, query_R]`, return 0. * **Full Overlap:** If `[node.l, node.r]` is fully contained within `[query_L, query_R]`, return `node.sum`. 2. **Recursive Step:** * `push_down(node)` (Crucial: apply lazy tags before querying children to ensure current values are reflected). * Return `query_sum(node.left_child, query_L, query_R) + query_sum(node.right_child, query_L, query_R)`. **Complexity Analysis:** The segment tree has `O(N)` nodes. * **Build:** `O(N)` * **Query (`query_sum`):** `O(log N)` (standard segment tree query). * **Update (`update_range`):** This is the tricky part. The `node.second_mx < X` base case is what makes it efficient. When this condition is met, we don't recurse further, saving time. It can be shown that an element's value decreases at most `log V` times (where `V` is the maximum possible initial value). Each time an element decreases, we traverse `O(log N)` nodes. This leads to a total time complexity of roughly `O((N + M) log N log V)` for `M` operations, which often simplifies to `O((N+M) log^2 N)` or even `O((N+M) log N)` with a tighter amortized analysis depending on specific properties. The `log V` factor can be considered small for typical integer ranges. **Implementation Details:** * Initialize `second_mx` to a very small negative number (e.g., `-1` if all values are non-negative, or `LLONG_MIN`). * Carefully handle `cnt_mx` when merging children's data in `pull_up`. * Ensure `lazy_val` is properly cleared and propagated. This technique is a powerful tool for problems involving range updates that have a "threshold" effect (like min/max updates), where elements become "saturated" and no longer affected by subsequent updates of a similar type.

हमारे ड्रेसअप गेम सेक्शन में जाकर और भी मज़ेदार गेम्स देखें और Princess Paper Craft Art, Merry Christmas Dressup, Girlzone Streetwear, और Bratz Dollmaker जैसे लोकप्रिय गेम्स खेलें — ये सभी Y8 Games पर तुरंत खेलने के लिए उपलब्ध हैं।