Codechef FNCS Chef and Churu

Disciption

Chef has recently learnt Function and Addition. He is too exited to teach this to his friend Churu. Chef and Churu are very fast friends, they share their knowledge whenever they meet. Chef use to give a lot of exercises after he teaches some concept to Churu.

Chef has an array of N numbers. He also has N functions. Each function will return the sum of all numbers in the array from L_i to R_i. So Chef asks churu a lot of queries which are of two types.

Type 1: Change the x^th element of the array to y.
Type 2: Return the sum of all functions from m to n.

Now Churu has started to solve, but Chef realize that it is tough for him to decide whether Churu is correct or not. So he needs your help , will you help him out ?

Input Format

First Line is the size of the array i.e. N
Next Line contains N space separated numbers A_i denoting the array
Next N line follows denoting L_i and R_i for each functions.
Next Line contains an integer Q , number of queries to follow.
Next Q line follows , each line containing a query of Type 1 or Type 2.
1 x y : denotes a type 1 query,where x and y are integers
2 m n : denotes a type 2 query where m and n are integers

Output Format

For each query of type 2 , output as asked above.

Constraints

1 ≤ N ≤ 10 ⁵
1 ≤ A _i ≤ 10 ⁹
1 ≤ L _i ≤ N
L _i ≤ R _i ≤ N
1 ≤ Q ≤ 10 ⁵
1 ≤ x ≤ N
1 ≤ y ≤ 10 ⁹
1 ≤ m ≤ N
m ≤ n ≤ N

Subtask

Subtask 1: N ≤ 1000 , Q ≤ 1000 , 10 points
Subtask 2: R-L ≤ 10 , all x will be distinct ,10 points
Subtask 3: Refer to constraints above , 80 points

Sample Input

5
1 2 3 4 5
1 3
2 5
4 5
3 5
1 2
4
2 1 4
1 3 7
2 1 4
2 3 5

Sample Output

41
53
28

Explanation

Functions values initially :
F[1] = 1+ 2 + 3 = 6
F[2] = 2 + 3 + 4 + 5 = 14
F[3] = 4+5 = 9
F[4] = 3+4+5 = 12
F[5] = 1+2 = 3
Query 1: F[1] + F[2] + F[3] + F[4] = 41
After Update , the Functions are :
F[1] = 10 , F[2] = 18 , F[3] = 9 , F[4] = 16 , F[5] = 3
Query 3: F[1] + F[2] + F[3] + F[4] = 53
Query 4: F[3]+F[4]+F[5] = 28

本来想用分块看看能不能水过的，，，结果怎么就水过了23333

我们设每个块内的元素有M个，那么就有(N/M)个块。

我们对函数分块了之后，可以用数组tag[i][j]表示第i个块内的函数总共加了几次第j个元素。

这个数组的预处理差分之后前缀和一下就好了。

然后有了这个数组之后我们就可以很方便的维护每个块内函数的和了。

对于整块的话，修改的复杂度O(N/M) [考虑这个元素对每个块的总和的影响] ，查询的复杂度也是 O(N/M) ，因为最多要查询N/M个块。

而零散的块用树状数组维护一下元素数组的前缀和就好了，修改复杂度 O(log N),查询复杂度 O(M * log N)。

可以解出 M = sqrt(N/ log N) 的时候程序的效果应该是最好的，但是限于我们开不出这么大的数组，所以M只能取sqrt(N)稍小一点。

我取的是sqrt(N)/1.414 ,然后就A了。

#include<bits/stdc++.h>
#define ll unsigned long long
#define maxn 100005
using namespace std;
int n,a[maxn],sz,opt,le,ri,mx,m;
int tag[505][maxn],bl[maxn];
ll tot[505],f[maxn],ans;
int l[maxn],r[maxn];
 
inline void update(int x,int y){
	for(;x<=n;x+=x&-x) f[x]+=(ll)y;
}
 
inline ll query(int x){
	ll an=0;
	for(;x;x-=x&-x) an+=f[x];
	return an;
}
 
inline void input(){
	scanf("%d",&n),sz=sqrt(n/2+1);
	for(int i=1;i<=n;i++){
		scanf("%d",a+i);
		update(i,a[i]);
	}
 
	for(int i=1;i<=n;i++){
		bl[i]=(i-1)/sz+1;
		scanf("%d%d",l+i,r+i);
		tag[bl[i]][l[i]]++;
		tag[bl[i]][r[i]+1]--;
	}
}
 
inline void prework(){
	mx=bl[n];
	for(int i=1;i<=mx;i++)
	    for(int j=1;j<=n;j++){
	    	tag[i][j]+=tag[i][j-1];
	    	tot[i]+=a[j]*(ll)tag[i][j];
		}
}
 
inline void TOL(){
	int derta=ri-a[le];
	update(le,derta);
	for(int i=1;i<=mx;i++) tot[i]+=tag[i][le]*(ll)derta;
 
	a[le]=ri;
}
 
inline void REQ(){
	ans=0;
 
	if(bl[le]==bl[ri]){
		for(;le<=ri;le++) ans+=query(r[le])-query(l[le]-1);
	}
	else{
		for(;bl[le]==bl[le-1];le++) ans+=query(r[le])-query(l[le]-1);
		for(;bl[ri]==bl[ri+1];ri--) ans+=query(r[ri])-query(l[ri]-1);
		for(int j=bl[le];j<=bl[ri];j++) ans+=tot[j];
	}
 
	printf("%llu\n",ans);
}
 
int main(){
	input();
	prework();
	scanf("%d",&m);
	while(m--){
		scanf("%d%d%d",&opt,&le,&ri);
		if(opt==1) TOL();
		else REQ();
	}
	return 0;
}