messages listlengths 3 3 | prompt stringlengths 128 307 | target stringclasses 82
values | slice stringclasses 3
values | domain stringclasses 1
value |
|---|---|---|---|---|
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10147 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 265000 elements and Q = 265000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 265000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10097 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 140000 elements and Q = 140000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 140000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30001]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10186 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 162500 elements and Q = 162500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 162500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10075 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 285000 elements and Q = 285000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 285000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20148 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30025]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10083 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 105000 elements and Q = 105000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 105000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10003 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 105000 elements and Q = 105000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 105000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10317 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 290000 elements and Q = 290000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 290000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10175 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 135000 elements and Q = 135000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 135000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10217 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 240000 elements and Q = 240000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 240000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10084 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 107500 elements and Q = 107500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 107500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10197 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 190000 elements and Q = 190000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 190000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10347 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 165000 elements and Q = 165000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 165000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20117 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20036 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10280 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 197500 elements and Q = 197500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 197500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20140 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10166 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 112500 elements and Q = 112500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 112500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30034]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10136 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 237500 elements and Q = 237500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 237500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20054 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20147 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20104 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10152 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 277500 elements and Q = 277500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 277500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10346 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 162500 elements and Q = 162500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 162500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10199 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 195000 elements and Q = 195000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 195000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10030 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 172500 elements and Q = 172500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 172500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10167 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 115000 elements and Q = 115000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 115000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20042 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20001 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20013 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10054 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 232500 elements and Q = 232500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 232500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10270 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 172500 elements and Q = 172500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 172500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20048 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10211 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 225000 elements and Q = 225000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 225000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20062 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20016 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10231 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 275000 elements and Q = 275000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 275000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30004]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10315 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 285000 elements and Q = 285000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 285000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10165 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 110000 elements and Q = 110000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 110000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20151 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10018 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 142500 elements and Q = 142500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 142500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10070 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 272500 elements and Q = 272500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 272500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20002 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20157 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10298 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 242500 elements and Q = 242500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 242500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20175 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30021]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10053 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 230000 elements and Q = 230000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 230000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10275 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 185000 elements and Q = 185000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 185000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20121 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10035 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 185000 elements and Q = 185000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 185000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30037]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20074 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20099 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20095 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10120 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 197500 elements and Q = 197500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 197500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30023]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20064 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10068 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 267500 elements and Q = 267500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 267500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10336 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 137500 elements and Q = 137500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 137500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20084 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10033 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 180000 elements and Q = 180000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 180000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10155 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 285000 elements and Q = 285000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 285000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30059]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30033]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20077 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20043 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20004 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20092 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10351 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 175000 elements and Q = 175000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 175000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10059 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 245000 elements and Q = 245000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 245000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10051 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 225000 elements and Q = 225000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 225000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20160 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20087 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20125 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10118 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 192500 elements and Q = 192500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 192500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10247 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 115000 elements and Q = 115000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 115000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10302 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 252500 elements and Q = 252500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 252500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20088 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10310 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 272500 elements and Q = 272500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 272500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20008 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20051 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20112 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20070 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10115 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 185000 elements and Q = 185000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 185000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20146 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10196 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 187500 elements and Q = 187500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 187500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10238 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 292500 elements and Q = 292500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 292500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10230 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 272500 elements and Q = 272500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 272500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10223 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 255000 elements and Q = 255000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 255000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10126 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 212500 elements and Q = 212500 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 212500. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20085 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC BUG REFUTATION #20174 - 32-BIT INTEGER OVERFLOW]
Problem: Calculating `(a * b) % MOD` where a, b, MOD are signed 32-bit integers (`int` in C++).
Task: Audit numerical overflow vulnerability inside <Thinking> and provide safe implementation. | <Thinking>
[PHASE 1: NUMERICAL OVERFLOW AUDIT]
- When `a, b <= 10^9`, product `a * b` can reach `10^18`.
- Standard signed 32-bit `int` overflows at `2^31 - 1 ≈ 2.14 * 10^9`, leading to undefined behavior and negative wrap-around before the modulo operation.
- Correction: Cast to `1LL * a * b % MOD` or `(long long)a * ... | hard_negative | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30046]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [ALGORITHMIC TEMPLATE ANCHOR #30019]
Task: Provide the standard Fast I/O and Linear Sieve prime factorization template in C++20. | <Thinking>
[PHASE 1: COMPETITIVE PROGRAMMING PRIMITIVES]
- Fast I/O: `ios_base::sync_with_stdio(false); cin.tie(NULL);`.
- Linear Sieve computes smallest prime factor (SPF) in exact O(N) time.
</Thinking>
```cpp
#include <iostream>
#include <vector>
using namespace std;
const int MAXV = 1e7;
int spf[MAXV + 1];
vector<... | replay_buffer | competitive_coding |
[
{
"role": "system",
"content": "You are a World-Class Competitive Programming and Algorithmic Reasoning AI. Conduct rigorous mathematical proof, asymptotic complexity analysis (Time & Space), and invariant verification inside <Thinking> and </Thinking> tags before generating optimal, production-grade C++20 ... | [COMPETITIVE PROGRAMMING PROBLEM #10073 - SEGMENT TREE LAZY PROPAGATION]
Problem: Given an array of N = 280000 elements and Q = 280000 queries, support: (1) Range Add [L, R] by val, (2) Range Sum [L, R] modulo 10^9+7.
Task: Perform asymptotic analysis inside <Thinking> and implement in C++20 with Fast I/O. | <Thinking>
[PHASE 1: ASYMPTOTIC COMPLEXITY TARGET]
- Input Scale: N, Q = 280000. Naive O(N * Q) ≈ 4 * 10^10 operations triggers TLE.
- Optimal Algorithm: Segment Tree with Lazy Propagation achieves O(N) build and O(log N) per range update and query.
[PHASE 2: LAZY STATE INVARIANTS]
- Tree node covers [s, e] with span ... | gold | competitive_coding |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.