【洛谷】【线段树】P1471 方差

【题目背景：】

滚粗了的HansBug在收拾旧数学书，然而他发现了什么奇妙的东西。

【题目描述：】

蒟蒻HansBug在一本数学书里面发现了一个神奇的数列，包含N个实数。他想算算这个数列的平均数和方差。

【输入格式：】

第一行包含两个正整数N、M，分别表示数列中实数的个数和操作的个数。

第二行包含N个实数，其中第i个实数表示数列的第i项。

接下来M行，每行为一条操作，格式为以下两种之一：

操作1：1 x y k ，表示将第x到第y项每项加上k，k为一实数。

操作2：2 x y ，表示求出第x到第y项这一子数列的平均数。

操作3：3 x y ，表示求出第x到第y项这一子数列的方差。

【输出格式：】

输出包含若干行，每行为一个实数，即依次为每一次操作2或操作3所得的结果（所有结果四舍五入保留4位小数）。

输入样例#： 

   -

输出样例#：
3.0000
2.0000
0.8000

输入输出样例

【算法分析：】

支持区间修改，区间询问，常规做法线段树

关于平均值;

　　维护一个区间和，区间平均值就是区间和/区间长度

关于方差：

　　设ave为序列a的平均值

　　s² = [(a₁ - ave)² + (a₂ - ave)² + ... + (a_n - ave)²] / n

　　展开可得：s² = a₁² + a₂² + ... + a_n²  - 2 * ave(a₁ + a₂ + ... + a_n) + n * ave²

可以发现，只需要多维护一个区间平方和，就可以求出方差。

但如果要修改某一区间内元素的值呢？

(a₁ + v)² + (a₂ + v)² + ... + (a_n + v)²

= a₁² + a₂² + ... + a_n² + 2v(a₁ + a₂ + .. + a_n) + n * v²

维护区间平方和时，标记下传和修改被包含区间值的操作是一样的，答案就很显然了.

注意坑点：读入的序列是实型，方差平均值和要修改的值也是实型，修改时传参的修改值也要是实型.

【代码：】

 //P1471 方差
 #include<iostream>
 #include<cstdio>
 using namespace std;

 const int MAXN = 1e5 + ;

 int n, m;
 double a[MAXN];
 struct Segment {
     double sum, squ, lazy;
 }t[MAXN << ];

 void Build(int o, int l, int r) {
     if(l == r) {
         t[o].sum = a[l];
         t[o].squ = a[l] * a[l];
     }
     else {
         int mid = (l + r) >> ;
         Build(o << , l, mid);
         Build(o << |, mid + , r);
         t[o].sum = t[o << ].sum + t[o << |].sum;
         t[o].squ = t[o << ].squ + t[o << |].squ;
     }
 }
 inline void down(int o, int len) {
     if(!t[o].lazy) return;
     t[o << ].squ +=  * t[o].lazy * t[o << ].sum
                         + t[o].lazy * t[o].lazy * (len - (len >> ));
     t[o << |].squ +=  * t[o].lazy * t[o << |].sum
                         　+ t[o].lazy * t[o].lazy * (len >> );
     t[o << ].sum += t[o].lazy * (len - (len >> ));
     t[o << |].sum += t[o].lazy * (len >> );
     t[o << ].lazy += t[o].lazy;
     t[o << |].lazy += t[o].lazy;
     t[o].lazy = ;
 }
 void Update(int o, int l, int r, int ul, int ur, double v) {
     if(ul <= l && r <= ur) {
         t[o].squ +=  * v * t[o].sum + v * v * (r - l + );
         t[o].sum += v * (r - l + );
         t[o].lazy += v;
     }
     else {
         down(o, r - l + );
         int mid = (l + r) >> ;
         if(ul <= mid) Update(o << , l, mid, ul, ur, v);
         if(ur > mid) Update(o << |, mid + , r, ul, ur, v);
         t[o].sum = t[o << ].sum + t[o << |].sum;
         t[o].squ = t[o << ].squ + t[o << |].squ;
     }
 }

 double ssum, ssqu;
 void Query(int o, int l, int r, int ql, int qr) {
     if(ql <= l && r <= qr) {
         ssum += t[o].sum;
         ssqu += t[o].squ;
     }
     else {
         down(o, r - l + );
         int mid = (l + r) >> ;
         if(ql <= mid) Query(o << , l, mid, ql, qr);
         if(qr > mid) Query(o << |, mid + , r, ql, qr);
     }
 }

 inline double Average(int l, int r) {
     ssum  = ssqu = ;
     Query(, , n, l, r);
     return ssum * 1.0 / (r - l + );
 }
 inline double S2(int l, int r) {
     ssum = ssqu = ;
     int num = r - l + ;
     Query(, , n, l, r);
     double ave = ssum * 1.0 / num;
     double ret = ssqu -  * ave * ssum + num * ave * ave;
     return ret / num;
 }

 int main() {
     scanf("%d%d", &n, &m);
     for(int i = ; i <= n; ++i)
         scanf("%lf", &a[i]);
     Build(, , n);
     while(m--) {
         int fl, x, y;
         scanf("%d%d%d", &fl, &x, &y);
         if(fl == ) printf("%.4lf\n", Average(x, y));
         else if(fl == ) printf("%.4lf\n", S2(x, y));
         else {
             double k;
             scanf("%lf", &k);
             Update(, , n, x, y, k);
         }
     }
 }