# CHEFQUER - Editorial

Author: Aryan Agarwala, Daanish Mahajan
Tester: Istvan Nagy
Editorialist: Vichitr Gandas

EASY

# PREREQUISITES:

Fenwick Trees (Binary Indexed Trees), Segment Trees, Range Updates

# PROBLEM:

Given an array A consisting of size N. Process Q queries of the following types:

1 L R X - Add (X+i−L)^2 to A_i, for all i in [L,R]

2 i - Output A_i for i∈[1,N]

# QUICK EXPLANATION:

The given queries can be easily processed with binary indexed tress or segment trees.

# EXPLANATION:

### Processing type 1 queries

Let’s look at the first query:
1 L R X - Add (X+i−L)^2 to A_i, for all i in [L,R]
Here we are adding (X+i−L)^2. Let y = X-L. Now lets expand this term:
(X+i−L)^2 = (X-L+i)^2
= (y+i)^2
=y^2 + 2*y*i + i^2

Now lets say we performed two queries of type 1 with y=y_1 and y=y_2 respectively. Let’s see what value we added to A_i after the two queries. We add following to A_i.
(y_1^2 + 2*y_1*i + i^2) + (y_2^2 + 2*y_2*i + i^2)
=(y_1^2 + y_2^2) + (2*y_1 + 2*y_2)*i + (1+1)*i^2

Similarly after we perform k queries of type 1, A_i will be increased by:
(y_1^2 + y_2^2+...+y_k^2) + (2*y_1 + 2*y_2+...+2*y_k)*i + (1+1+...+1 (k \space times))*i^2

If we can maintain following sums \sum{y^2}, \sum{2*y} and \sum{1} for each i then we can easily answer what would be the value of A_i after performing these queries. These values can be maintained by using three binary indexed trees or segment trees. Let the data structures B_1 maintain the sum \sum{y^2}, B_2 maintain the sum \sum{2*y} and B_3 maintain the sum \sum{1}.

Now we can break the query of type 1 in following steps:

• Add y^2 to the range [L, R] in B_1.
• Add 2*y to the range [L,R] in B_2.
• Add 1 to the range [L,R] in B_3.

These are simple update queries which can be performed in O(logn) time in both segment trees and binary indexed trees.

### Answering type 2 queries

As we saw in the previous section, after k queries of type 1, A_i will be increased by:
(y_1^2 + y_2^2+...+y_k^2) + (2*y_1 + 2*y_2+...+2*y_k)*i + (1+1+...+1 (k \space times))*i^2
=\sum{y^2} + i* \sum{2*y} + i^2 * \sum{1}

Let the point query q_1(i) return the value at index i in B_1, q_2(i) return the value at index i in B_2 and q_3(i) return the value at index i in B_3. These are simple get queries for the value at index i which can be easily processed in O(logn) time in both segment trees and binary indexed trees.

Now the value added at index i would be:
q_1(i) + i*q_2(i) + i^2*q_3(i)

So answer to the query 2 \space i would be A_i + q_1(i) + i*q_2(i) + i^2*q_3(i).

### Algorithm

• Keep 3 fenwick arrays or segment trees B_1, B_2, B_3.
• For queries of type 1
• Now let y = X - L.
• For B_1 do a range update: add y ^ 2 for all i from L to R.
• For B_2 do a range update: add 2 * y for all i from L to R.
• For B_3 do a range update: add 1 for all i from L to R.
• For queries of type 2
• Let point query in i^{th} DS on index j be represented by q_i(j)
• Answer to the query is A_i + q_1(i) + i * q_2(i) + i^2 * q_3(i).

# TIME COMPLEXITY:

O(QlogN) for processing Q queries as each query takes O(logn) time.

# SOLUTIONS:

Setter's Solution
#include <bits/stdc++.h>
#define initrand mt19937 mt_rand(time(0));
#define rand mt_rand()
#define MOD 1000000007
#define INF 1000000000
#define int long long
#define mid(l, u) ((l+u)/2)
#define rchild(i) (i*2 + 2)
#define lchild(i) (i*2 + 1)
#define lz lazup(l, u, i);
//#define mp(x, y) make_pair(x, y)
using namespace std;
const int NLIM = 1e5;
const int QLIM = 1e5;
const int XLIM = 1e6;
const int N = 1e5 + 5;
const string INFILE = "2.in";
const string OUTFILE = "2.out";
//what do we need?
//negative stuff in segment tree
//make l greater than x
//1 30 50 5
//2 30
//big stuff in segment tree
//1 1 1e5 1e6
//1 1 1e5 1e6
initrand;
int n;
ofstream fout(INFILE);
ofstream fout1(OUTFILE);
int seg[4*N][3];
int lazy[4*N][3];
long long readInt(long long l,long long r,char endd){
long long x=0;
int cnt=0;
int fi=-1;
bool is_neg=false;
while(true){
char g=getchar();
if(g=='-'){
assert(fi==-1);
is_neg=true;
continue;
}
if('0'<=g && g<='9'){
x*=10;
x+=g-'0';
if(cnt==0){
fi=g-'0';
}
cnt++;
assert(fi!=0 || cnt==1);
assert(fi!=0 || is_neg==false);

assert(!(cnt>19 || ( cnt==19 && fi>1) ));
} else if(g==endd){
if(is_neg){
x= -x;
}
assert(l<=x && x<=r);
return x;
} else {
assert(false);
}
}
}
string readString(int l,int r,char endd){
string ret="";
int cnt=0;
while(true){
char g=getchar();
assert(g!=-1);
if(g==endd){
break;
}
cnt++;
ret+=g;
}
assert(l<=cnt && cnt<=r);
return ret;
}
long long readIntSp(long long l,long long r){
}
long long readIntLn(long long l,long long r){
}
string readStringLn(int l,int r){
}
string readStringSp(int l,int r){
}
void lazup(int l, int u, int i, int k){
if(lazy[i][k] == 0) return;
seg[i][k] += lazy[i][k];
if(l!=u) {
lazy[lchild(i)][k] += lazy[i][k];
lazy[rchild(i)][k] += lazy[i][k];
}
lazy[i][k] = 0;
}
int update(int l, int u, int i, int ll, int uu, int x, int k) {
lazup(l, u, i, k);
if (l >= ll && u <= uu) {
lazy[i][k] += x;
lazup(l, u, i, k);
return seg[i][k];
}
if (l > uu || u < ll) return seg[i][k];
return seg[i][k] = max(update(l, mid(l, u), lchild(i), ll, uu, x, k),
update(mid(l, u) + 1, u, rchild(i), ll, uu, x, k));
}
int query(int l, int u, int i, int ll, int uu, int k){
lazup(l, u, i, k);
if(l>=ll && u<=uu){
return seg[i][k];
}
if(l>uu || u<ll) return -1e18;
return max(query(l, mid(l, u), lchild(i), ll, uu, k), query(mid(l, u)+1, u, rchild(i), ll, uu, k));
}
void q1(int l, int r, int x){
update(1, n, 0, l, r, x*x + l*l - 2*x*l, 0);
update(1, n, 0, l, r, 2*x - 2*l, 1);
update(1, n, 0, l, r, 1, 2);
}
int q2(int i){
int tp = query(1, n, 0,i, i, 0) + query(1, n, 0,i, i, 1)*i + query(1, n, 0,i, i, 2)*i*i;//16, 24, 9
cout<<tp<<endl;
}
int getr(int l, int r){
int temp = rand;
temp %= (r - l + 1);
return (l + temp);
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
n  = readIntSp(1, 1e5);
q = readIntLn(1, 1e5);
for(int i = 1;i<n;i++){
int ai;
ai = readIntSp(-1e6, 1e6);
update(1, n, 0, i, i, ai, 0);
}
int an;
an = readIntLn(-1e6, 1e6);
update(1, n, 0, n, n, an, 0);
while(q--){
int type;
type = readIntSp(1, 2);
if(type==1){
int l, r, x;
l = readIntSp(1, n);
r = readIntSp(l, n);
x = readIntLn(-1e6, 1e6);
q1(l, r, x);
}
else{
int i;
i = readIntLn(1, n);
q2(i);
}
}
}

Tester's Solution
#include <iostream>
#include <cassert>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <random>

#ifdef HOME
#include <windows.h>
#endif

#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)

template<class T> bool umin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool umax(T &a, T b) { return a < b ? (a = b, true) : false; }

using namespace std;

template<typename T>
struct FenwickTree
{
vector<T> data;
void init(size_t n)
{
data.resize(n);
}
void init(const vector<T>& v)
{
data.resize(v.size());
forn(i, v.size())
inc(i, v[i]);
}
void fastInit(const vector<T>& v)
{
data = v;
forn(i, v.size())
{
size_t np = i | (i + 1);
if (np < v.size())
data[np] += data[i];
}
}
void inc(size_t pos, T val)
{
for (; pos < data.size(); pos |= pos + 1)
{
data[pos] += val;
}
}

void incRange(size_t posL, size_t posR, T val)
{
inc(posL, val);
inc(posR+1, -val);
}

T sum(size_t pos) const
{
T ret = 0;
for (++pos; pos; pos &= pos - 1)
ret += data[pos - 1];
return ret;
}
};

long long readInt(long long l, long long r, char endd) {
long long x = 0;
int cnt = 0;
int fi = -1;
bool is_neg = false;
while (true) {
char g = getchar();
if (g == '-') {
assert(fi == -1);
is_neg = true;
continue;
}
if ('0' <= g && g <= '9') {
x *= 10;
x += g - '0';
if (cnt == 0) {
fi = g - '0';
}
cnt++;
assert(fi != 0 || cnt == 1);
assert(fi != 0 || is_neg == false);

assert(!(cnt > 19 || (cnt == 19 && fi > 1)));
}
else if (g == endd) {
assert(cnt > 0);
if (is_neg) {
x = -x;
}
assert(l <= x && x <= r);
return x;
}
else {
//assert(false);
}
}
}

string readString(int l, int r, char endd) {
string ret = "";
int cnt = 0;
while (true) {
char g = getchar();
assert(g != -1);
if (g == endd) {
break;
}
cnt++;
ret += g;
}
assert(l <= cnt && cnt <= r);
return ret;
}
long long readIntSp(long long l, long long r) {
return readInt(l, r, ' ');
}
long long readIntLn(long long l, long long r) {
return readInt(l, r, '\n');
}
string readStringLn(int l, int r) {
return readString(l, r, '\n');
}
string readStringSp(int l, int r) {
return readString(l, r, ' ');
}

int main(int argc, char** argv)
{
#ifdef HOME
if(IsDebuggerPresent())
{
freopen("../in.txt", "rb", stdin);
freopen("../out.txt", "wb", stdout);
}
#endif
uint32_t N = readIntSp(1, 100'000);
uint32_t Q = readIntLn(1, 100'000);
vector<int64_t> A(N);
int ctr = 0;
for (auto& ai : A)
{
++ctr;
if (ctr == N)
ai = readIntLn(-1'000'000, 1'000'000'000);
else
ai = readIntSp(-1'000'000, 1'000'000'000);
}

FenwickTree<int64_t> FenwickConstant, FenwickLinear, FenwickQuadr;
FenwickConstant.init(N);
FenwickLinear.init(N);

forn(q, Q)
{
int qtype = readIntSp(1, 2);
if (qtype == 1)
{
size_t L = readIntSp(1, N);
size_t R = readIntSp(1, N);
int64_t X = readIntLn(-1'000'000'000, 1'000'000'000);
X -= L;
--L;
--R;
FenwickConstant.incRange(L, R, X * X);
FenwickLinear.incRange(L, R, 2 * X);
}
else
{
size_t P = readIntLn(1, N);
--P;
int64_t res = A[P] + FenwickConstant.sum(P) +
(P + 1) * FenwickLinear.sum(P) +
(P + 1) * (P + 1) * FenwickQuadr.sum(P);
printf("%lld\n",res);
}
}

return 0;
}


Editorialist's Solution
/*
* @author: vichitr
* @date: 26th June 2021
*/

#include <bits/stdc++.h>
using namespace std;
#define int long long

// Template taken from cp-algorithms
struct FenwickTree {
vector<int> bit;  // binary indexed tree
int n;

FenwickTree(int n) {
this->n = n + 1;
bit.assign(n + 1, 0ll);
}

void add(int idx, int val) {
for (++idx; idx < n; idx += idx & -idx)
bit[idx] += val;
}

void range_add(int l, int r, int val) {
add(r + 1, -val);
}

int get(int idx) { //
int ret = 0;
for (++idx; idx > 0ll; idx -= idx & -idx)
ret += bit[idx];
return ret;
}
};

void solve() {
int n, q; cin >> n >> q;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
FenwickTree B1(n), B2(n), B3(n);

while (q--) {
int type;; cin >> type;
if (type == 1) {
int l, r, x; cin >> l >> r >> x;
int y = x - l;
l--, r--;
B1.range_add(l, r, y * y);
B2.range_add(l, r, y * 2);
}
else {
int i; cin >> i;
int ans = a[i - 1] + B1.get(i - 1) + i * B2.get(i - 1) + i * i * B3.get(i - 1);
cout << ans << '\n';
}
}
}

signed main() {

#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif

int t = 1;
// cin >> t;
while (t--) {
solve();
}
return 0;
}


# VIDEO EDITORIAL:

If you have other approaches or solutions, let’s discuss in comments.

2 Likes

why is bruteforce passing? please rejudge all solutions with stronger testcases.

30 Likes

Weak test cases, even O(NQ) will give AC.

12 Likes

True. Bruteforce solution passes. I was wondering why so many submissions in division C on this problem. But later came to know about weak test data.

10 Likes

Really Weak Testcases.

4 Likes

Please Rejudge with strong test cases.

9 Likes

It passed in some cases and didnt in some, please rejudge

5 Likes

it’s not really easy problem move it to medium , test cases are weak that doesn’t means problem is easy

9 Likes

very weak test cases. please rejudge with strong test cases.

3 Likes

I tried in brute force but it didnt pass.
Any optimization required?

https://www.codechef.com/submit/CHEFQUER

1 Like

Here at div 2 we have less submission for this question than sleep cycle and div 3 folks hitting 1k submissions , the constraints doesn’t and shouldn’t allow o(n*q) as its a Range Query Updation question.
I don’t blame div3 as they are newbies and may not be knowing much about time constraints.

6 Likes

we respected the question but div3 people go brrrrr ezpz

4 Likes

It was actually less than 200 when about 25 mins were left and i decided to leave the ques as i knew bruterforce wudnt work(i still tried it as a vague attempt in python) and then i opened after contest ended and submissions count increased to 1k.I think someone revealed it that britefore in c++ is passing

4 Likes

Yeah then the domino effect, everyone tried bruteforce.

3 Likes

Difficulty : EASY??

2 Likes

share your code properly

sometimes over smartness kills

When will the ratings will appear for starters div 3

I tried the same code in div 2 and its showing TLE…but for div 3 I guess they have given a free hand

1 Like

was it intentional?