相关分析 BZOJ 4821

相关分析

【问题描述】

Frank对天文学非常感兴趣，他经常用望远镜看星星，同时记录下它们的信息，比如亮度、颜色等等，进而估算出星星的距离，半径等等。Frank不仅喜欢观测，还喜欢分析观测到的数据。他经常分析两个参数之间（比如亮度和半径）是否存在某种关系。现在Frank要分析参数X与Y之间的关系。他有n组观测数据，第i组观测数据记录了x_i和y_i。他需要一下几种操作1 L,R：用直线拟合第L组到底R组观测数据。用xx表示这些观测数据中x的平均数，用yy表示这些观测数据中y的平均数，即

xx=Σx_i/(R-L+1)(L<=i<=R)

yy=Σy_i/(R-L+1)(L<=i<=R)

如果直线方程是y=ax+b，那么a应当这样计算：

a=(Σ(x_i-xx)(y_i-yy))/(Σ(x_i-xx)(x_i-xx)) (L<=i<=R)

你需要帮助Frank计算a。

2 L,R,S,T：

Frank发现测量数据第L组到底R组数据有误差，对每个i满足L <= i <= R，x_i需要加上S，y_i需要加上T。

3 L,R,S,T：

Frank发现第L组到第R组数据需要修改，对于每个i满足L <= i <= R，x_i需要修改为(S+i)，y_i需要修改为(T+i)。

【输入格式】

第一行两个数n,m，表示观测数据组数和操作次数。

接下来一行n个数，第i个数是x_i。

接下来一行n个数，第i个数是y_i。

接下来m行，表示操作，格式见题目描述。

1<=n,m<=10^5,0<=|S|,|T|,|x_i|,|y_i|<=10^5

保证1操作不会出现分母为0的情况。

【输出格式】

对于每个1操作，输出一行，表示直线斜率a。

选手输出与标准输出的绝对误差不超过10^-5即为正确。

【样例输入】

3 5
1 2 3
1 2 3
1 1 3
2 2 3 -3 2
1 1 2
3 1 2 2 1
1 1 3

【样例输出】

1.0000000000
-1.5000000000
-0.6153846154

---

题解:

对于线性回归方程我们把它拆分,x平方和,x权值和,y权值和,xy权值和,x平方和

第二个第三个操作用初中学的完全平方公式拆一拆就好了

记得爆 long long MMP

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
inline void Scan(int &x)
{
    char c;
    bool o = false;
    while(!isdigit(c = getchar()))
        if(c == '-')
            o = true;
    x = c - '0';
    while(isdigit(c = getchar()))
        x = x * 10 + c - '0';
    if(o) x = -x;
}
const int maxn = 1e5 + 1;
const int maxs = maxn << 2;
struct ele
{
    long long x, y;
    double xy, sx;
    inline void print()
    {
        printf("%lf %lf %lf %lf\n", (double) x, (double) y, (double) xy, (double) sx);
    }
    inline void empty()
    {
        x = y = xy = sx = 0;
    }
};
struct tag
{
    long long s, t;
    inline bool exist()
    {
        return s || t;
    }
    inline void empty()
    {
        s = t = 0;
    }
};
tag mark[maxs], sign[maxs];
ele ans, add;
ele tr[maxs];
int n, m;
int x[maxn], y[maxn];
double sum[maxn];
inline ele operator + (ele a, ele b)
{
    return (ele) {a.x + b.x, a.y + b.y, a.xy + b.xy, a.sx + b.sx};
}
inline tag operator + (tag a, tag b)
{
    return (tag) {a.s + b.s, a.t + b.t};
}
void Build(int k, int l, int r)
{
    if(l == r)
    {
        tr[k] = (ele) {x[l], y[l], (double) x[l] * y[l], (double) x[l] * x[l]};
        return;
    }
    int mi = l + r >> 1;
    int lc = k << 1, rc = k << 1 | 1;
    Build(lc, l, mi), Build(rc, mi + 1, r);
    tr[k] = tr[lc] + tr[rc];
}
inline void Add(int k, int n, long long s, long long t)
{
    long long x, y;
    double xy, sx;
    x = n * s;
    y = n * t;
    xy = (double) s * tr[k].y + (double) t * tr[k].x + (double) n * s * t;
    sx = (double) n * s * s + 2 * s * (double) tr[k].x;
    add = (ele) {x, y, xy, sx};
    tr[k] = tr[k] + add;
    mark[k] = mark[k] + (tag) {s, t};
}
inline long long Sum(long long l, long long r, int n)
{
    return (l + r) * n / 2;
}
inline void Change(int k, double s, double t, int l, int r)
{
    int n = r - l + 1;
    double x, y, xy, sx;
    x = Sum(s + l, s + r, n);
    y = Sum(t + l, t + r, n);
    xy = (double) n * s * t + (double) (s + t) * Sum(l, r, n) + sum[r] - sum[l - 1];
    sx = (double) n * s * s + sum[r] - sum[l - 1] + (double) 2 * s * Sum(l, r, n);
    tr[k] = (ele) {x, y, xy, sx};
    sign[k] = (tag) {s, t};
    mark[k].empty();
}
inline void Down(int k, int l, int r)
{
    int lc = k << 1, rc = k << 1 | 1;
    int mi = l + r >> 1;
    double s, t;
    if(sign[k].exist())
    {
        s = sign[k].s, t = sign[k].t;
        Change(lc, s, t, l, mi), Change(rc, s, t, mi + 1, r);
        sign[k].empty();
    }
    if(mark[k].exist())
    {
        s = mark[k].s, t = mark[k].t;
        Add(lc, mi - l + 1, s, t), Add(rc, r - mi, s, t);
        mark[k].empty();
    }
}
void Query(int k, int l, int r, int x, int y)
{
    if(x <= l && r <= y)
    {
        ans = ans + tr[k];
        return;
    }
    Down(k, l, r);
    int mi = l + r >> 1;
    if(x <= mi) Query(k << 1, l, mi, x, y);
    if(y > mi) Query(k << 1 | 1, mi + 1, r, x, y);
}
void Insert(int k, int l, int r, int x, int y, int s, int t)
{
    if(x <= l && r <= y)
    {
        Add(k, r - l + 1, s, t);
        return;
    }
    Down(k, l, r);
    int mi = l + r >> 1;
    int lc = k << 1, rc = k << 1 | 1;
    if(x <= mi) Insert(lc, l, mi, x, y, s, t);
    if(y > mi) Insert(rc, mi + 1, r, x, y, s, t);
    tr[k] = tr[lc] + tr[rc];
}
void Modify(int k, int l, int r, int x, int y, int s, int t)
{
    if(x <= l && r <= y)
    {
        Change(k, s, t, l, r);
        return;
    }
    Down(k, l, r);
    int mi = l + r >> 1;
    int lc = k << 1, rc = k << 1 | 1;
    if(x <= mi) Modify(lc, l, mi, x, y, s, t);
    if(y > mi) Modify(rc, mi + 1, r, x, y, s, t);
    tr[k] = tr[lc] + tr[rc];
}
int main()
{
    Scan(n), Scan(m);
    for(int i = 1; i <= n; ++i) Scan(x[i]);
    for(int i = 1; i <= n; ++i) Scan(y[i]);
    for(int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (double) i * i;
    Build(1, 1, n);
    int o, x, y, s, t;
    int len;
    long long meanx;
    long double up, down, meany;
    while(m--)
    {
        Scan(o), Scan(x), Scan(y);
        switch(o)
        {
            case 1:
            {
                ans.empty();
                Query(1, 1, n, x, y);
                len = y - x + 1;
                meanx = ans.x;
                meany = (double) ans.y / len;
                up = ans.xy - meanx * meany;
                down = ans.sx - (double) meanx * meanx / len;
                double answer = up / down;
                printf("%.10lf\n", answer);
                break;
            }
            case 2:
            {
                Scan(s), Scan(t);
                Insert(1, 1, n, x, y, s, t);
                break;
            }
            case 3:
            {
                Scan(s), Scan(t);
                Modify(1, 1, n, x, y, s, t);
                break;
            }
        }
    }
}