BZOJ4817 SDOI2017 相关分析

4821: [Sdoi2017]相关分析

Time Limit: 10 Sec Memory Limit: 128 MBSec Special Judge

Description

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)。

Input

第一行两个数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的情况。

Output

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

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

Sample Input

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

Sample Output

1.0000000000
-1.5000000000
-0.6153846154

　　本来我是不会想起这道题的。但是有这么一个故事：

　　开学，学科，数学课，变量的相关性。

　　下课后，同学们聚在一起搞事。

　　QT：“你记不记得SDOI2017 D2T3 相关分析？”

　　我：“……蛤？”

　　QT：“题目没给你化简，数学书上化简了。”

　　我：“……蛤？”

　　QT：“拆开式子之后有4个东西要维护，我不会(想)写。”

　　我：“……蛤？”

　　…………

　　在机房写作业。

　　QT：“不行这个数学作业太难算了，我要编程计算。”

　　Anson：“你可以打一波SDOI2017 相关分析。”

　　QT(虚伪地)：“我不会打。”

　　然而因为我早已从Jesse那里蒯了一个calc.cpp，作业已经写完了。

　　然后我就只是想看看传说中的SDOI2017D2T3是什么题，我是不是忘的一干二净。

　　然后发现果然忘得一干二净。

　　然后就有了下面的事情。

　　题解就是显而易见的线段树。

　　把式子拆开看，你就会得到：

　　上下的后面那一截可以再化简一下。

　　然后就只要维护4个东西：

　　 $\sum{x_{i}},\ \sum{y_{i}},\ \sum{x_{i}^2},\ \sum{x_{i}y_{i}}$

　　这个就很simple了吧，线段树嘛。

　　对于操作2,3，把前后的式子拆一下，维护一下就好了。

　　可以先做codevs的线段树练习5 思路都是差不多的。

　　思维难度：高中数学。

　　代码难度：MDZZ。

　　PS：这道题就别再codevs交了，它没有SPJ。

#include    <iostream>
#include    <cstdio>
#include    <cstdlib>
#include    <algorithm>
#include    <vector>
#include    <cstring>
#include    <queue>
#include    <complex>
#include    <stack>
#define LL long long int
#define dob long double
#define ls (x<<1)
#define rs (x<<1|1)
using namespace std;
 
const int N = ;
struct Tree{
  dob x,y,xx,xy;
  Tree operator +(const Tree &t){
    return (Tree){x+t.x,y+t.y,xx+t.xx,xy+t.xy};
  }
}Tr[N*];
int n,m,lazy_vis[N];
dob X[N/],Y[N/],lazy_add1[N],lazy_add2[N],lazy_set1[N],lazy_set2[N];
 
inline int gi(){
  int x=,res=;char ch=getchar();
  while(ch>''||ch<''){if(ch=='-')res*=-;ch=getchar();}
  while(ch<=''&&ch>='')x=x*+ch-,ch=getchar();
  return x*res;
}
 
inline void build(int x,int l,int r){
  if(l==r){
    Tr[x]=(Tree){X[l],Y[l],1.0*X[l]*X[l],1.0*X[l]*Y[l]};
    return;
  }
  int mid=(l+r)>>;
  build(ls,l,mid);build(rs,mid+,r);
  Tr[x]=Tr[ls]+Tr[rs];
}
 
inline dob calc(dob l,dob r){
  return 0.5*(l+r)*(r-l+);
}
 
inline dob calcpow(dob l,dob r){
  l-=;
  dob p1=1.0*(r)*(r+)*(*r+)/6.0;
  dob p2=1.0*(l)*(l+)*(*l+)/6.0;
  return p1-p2;
}
 
inline void down(int x,int l,int r){
  int mid=(l+r)>>,sl=mid-l+,sr=r-mid;
  if(lazy_vis[x]){
    lazy_add1[ls]=lazy_add1[rs]=lazy_add2[ls]=lazy_add2[rs]=;
    lazy_vis[ls]=lazy_vis[rs]=;
    dob S=lazy_set1[x],T=lazy_set2[x];
    lazy_set1[ls]=lazy_set1[rs]=lazy_set1[x];
    lazy_set2[ls]=lazy_set2[rs]=lazy_set2[x];
    Tr[ls].xx=1.0*sl*S*S+2.0*S*calc(l,mid)+calcpow(l,mid);
    Tr[rs].xx=1.0*sr*S*S+2.0*S*calc(mid+,r)+calcpow(mid+,r);
    Tr[ls].xy=1.0*sl*S*T+1.0*(S+T)*calc(l,mid)+calcpow(l,mid);
    Tr[rs].xy=1.0*sr*S*T+1.0*(S+T)*calc(mid+,r)+calcpow(mid+,r);
    Tr[ls].x=1.0*sl*S+calc(l,mid);Tr[rs].x=1.0*sr*S+calc(mid+,r);
    Tr[ls].y=1.0*sl*T+calc(l,mid);Tr[rs].y=1.0*sr*T+calc(mid+,r);
    lazy_vis[x]=;
  }
  if(lazy_add1[x] || lazy_add2[x]){
    dob S=lazy_add1[x],T=lazy_add2[x];
    lazy_add1[ls]+=S;lazy_add1[rs]+=S;
    lazy_add2[ls]+=T;lazy_add2[rs]+=T;
    Tr[ls].xx+=2.0*Tr[ls].x*S+1.0*sl*S*S;
    Tr[rs].xx+=2.0*Tr[rs].x*S+1.0*sr*S*S;
    Tr[ls].xy+=1.0*Tr[ls].x*T+1.0*Tr[ls].y*S+1.0*sl*S*T;
    Tr[rs].xy+=1.0*Tr[rs].x*T+1.0*Tr[rs].y*S+1.0*sr*S*T;
    Tr[ls].x+=1.0*sl*S;Tr[rs].x+=1.0*sr*S;
    Tr[ls].y+=1.0*sl*T;Tr[rs].y+=1.0*sr*T;
    lazy_add1[x]=lazy_add2[x]=;
  }
}
 
inline Tree query_1(int x,int l,int r,int xl,int xr){
  if(xl<=l && r<=xr)return Tr[x];
  down(x,l,r);int mid=(l+r)>>;
  if(xr<=mid)return query_1(ls,l,mid,xl,xr);
  else if(xl>mid)return query_1(rs,mid+,r,xl,xr);
  return query_1(ls,l,mid,xl,mid)+query_1(rs,mid+,r,mid+,xr);
}
 
inline void update_2(int x,int l,int r,int xl,int xr,dob S,dob T){
  if(xl<=l && r<=xr){
    lazy_add1[x]+=S;lazy_add2[x]+=T;
    Tr[x].xx+=2.0*Tr[x].x*S+1.0*(r-l+)*S*S;
    Tr[x].xy+=1.0*Tr[x].x*T+1.0*Tr[x].y*S+1.0*(r-l+)*S*T;
    Tr[x].x+=1.0*(r-l+)*S;Tr[x].y+=1.0*(r-l+)*T;
    return;
  }
  down(x,l,r);int mid=(l+r)>>;
  if(xr<=mid)update_2(ls,l,mid,xl,xr,S,T);
  else if(xl>mid)update_2(rs,mid+,r,xl,xr,S,T);
  else update_2(ls,l,mid,xl,mid,S,T),update_2(rs,mid+,r,mid+,xr,S,T);
  Tr[x]=Tr[ls]+Tr[rs];
}
 
inline void update_3(int x,int l,int r,int xl,int xr,dob S,dob T){
  if(xl<=l && r<=xr){
    lazy_add1[x]=lazy_add2[x]=;
    lazy_vis[x]=;lazy_set1[x]=S;lazy_set2[x]=T;
    Tr[x].xx=1.0*(r-l+)*S*S+2.0*S*calc(1.0*l,1.0*r)+calcpow(1.0*l,1.0*r);
    Tr[x].xy=1.0*(r-l+)*S*T+1.0*(S+T)*calc(l,r)+calcpow(l,r);
    Tr[x].x=1.0*(r-l+)*S+calc(l,r);Tr[x].y=1.0*(r-l+)*T+calc(l,r);
    return;
  }
  down(x,l,r);int mid=(l+r)>>;
  if(xr<=mid)update_3(ls,l,mid,xl,xr,S,T);
  else if(xl>mid)update_3(rs,mid+,r,xl,xr,S,T);
  else update_3(ls,l,mid,xl,mid,S,T),update_3(rs,mid+,r,mid+,xr,S,T);
  Tr[x]=Tr[ls]+Tr[rs];
}   
 
int main()
{
  /*freopen(".in","r",stdin);
    freopen(".out","w",stdout);*/
  n=gi();m=gi();
  for(int i=;i<=n;++i)X[i]=gi();
  for(int i=;i<=n;++i)Y[i]=gi();
  build(,,n);
  for(int i=;i<=m;++i){
    int type=gi();
    if(type==){
      int l=gi(),r=gi();
      Tree ans=query_1(,,n,l,r);
      dob fz=ans.xy-ans.x*ans.y/(r-l+);
      dob fm=ans.xx-ans.x*ans.x/(r-l+);
      printf("%.10Lf\n",fz/fm);
    }
    if(type==){
      int l=gi(),r=gi(),S=gi(),T=gi();
      update_2(,,n,l,r,1.0*S,1.0*T);
    }
    if(type==){
      int l=gi(),r=gi(),S=gi(),T=gi();
      update_3(,,n,l,r,1.0*S,1.0*T);
    }
  }
 
  /*fclose(stdin);
    fclose(stdout);*/
  return ;
}