题目描述

Frank对天文学非常感兴趣，他经常用望远镜看星星，同时记录下它们的信息，比如亮度、颜色等等，进而估算出星星的距离，半径等等。

Frank不仅喜欢观测，还喜欢分析观测到的数据。他经常分析两个参数之间（比如亮度和半径）是否存在某种关系。

现在Frank要分析参数XX 与YY 之间的关系。他有nn 组观测数据，第ii 组观测数据记录了x_ixi​ 和y_iyi​ 。他需要一下几种操作

  • 1 L,RL,R ：

用直线拟合第LL 组到底RR 组观测数据。用\overline{x}x 表示这些观测数据中xx 的平均数，用\overline{y}y​ 表示这些观测数据中yy 的平均数，即

\overline{x}={1 \over R-L+1} \sum _{i=L} ^R x_ix=R−L+11​∑i=LR​xi​

\overline{y}={1 \over R-L+1} \sum _{i=L} ^R y_iy​=R−L+11​∑i=LR​yi​

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

a={\sum_{i=L} ^R (x_i-\overline{x})(y_i-\overline{y}) \over \sum _{i=L} ^R (x_i -\overline{x})^2}a=∑i=LR​(xi​−x)2∑i=LR​(xi​−x)(yi​−y​)​

你需要帮助Frank计算aa 。

  • 2 L,R,S,TL,R,S,T ：

Frank发现测量数据第LL 组到底RR 组数据有误差，对每个ii 满足L \leq i \leq RL≤i≤R ，x_ixi​ 需要加上SS ，y_iyi​ 需要加上TT 。

  • 3 L,R,S,TL,R,S,T ：

Frank发现第LL 组到第RR 组数据需要修改，对于每个ii 满足L \leq i \leq RL≤i≤R ，x_ixi​ 需要修改为(S+i)(S+i) ，y_iyi​ 需要修改为(T+i)(T+i)。

输入输出格式

输入格式：

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

接下来一行nn 个数，第ii 个数是x_ixi​ 。

接下来一行nn 个数，第ii 个数是y_iyi​ 。

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

输出格式：

对于每个1操作，输出一行，表示直线斜率aa 。选手输出与标准输出的绝对误差或相对误差不超过10^{-5}10−5 即为正确。

输入输出样例

输入样例#1： 复制

  1. 3 5
  2. 1 2 3
  3. 1 2 3
  4. 1 1 3
  5. 2 2 3 -3 2
  6. 1 1 2
  7. 3 1 2 2 1
  8. 1 1 3
输出样例#1： 复制

  1. 1.0000000000
  2. -1.5000000000
  3. -0.6153846154

说明

对于20%的数据 1 \leq n,m \leq 10001≤n,m≤1000

另有20%的数据，没有3操作，且2操作中S=0S=0

另有30%的数据，没有3操作。

对于100%的数据，1 \leq n,m \leq 10^5,0 \leq |S|,|T| \leq 10^5,0 \leq |x_i|,|y_i| \leq 10^51≤n,m≤105,0≤∣S∣,∣T∣≤105,0≤∣xi​∣,∣yi​∣≤105

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

时间限制：1s

空间限制：128MB

考场上：

线段树裸题—>100

wtf？为什么会有类似等差数列的东西？—>70

maya..被卡精度了QWQ—>40

思路很简单，把式子拆开，然后你就会发现只需要维护$x_i*y_i,x_i,y_i,x^2$的和

具体怎么维护懒得打了（麻烦。）

建议看这里的第一篇题解

https://www.luogu.org/problemnew/solution/P3707

  1. // luogu-judger-enable-o2
  2. #include<cstdio>
  3. #include<queue>
  4. #include<cstring>
  5. #define int long long
  6. #define ls k<<1
  7. #define rs k<<1|1
  8. #define INF 1e8+10
  9. using namespace std;
  10. const int MAXN=1e6+;
  11. //#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,MAXN,stdin),p1==p2)?EOF:*p1++)
  12. inline int read()
  13. {
  14.     char c=getchar();int x=,f=;
  15.     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
  16.     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
  17.     return x*f;
  18. }
  19. struct node
  20. {
  21.     int l,r,siz;
  22.     double po;//x^2
  23.     double mul;//xi*yi
  24.     double sx,sy;//sigma
  25.     double ax,ay;//add
  26.     bool lazy;//memset
  27.     node(){sx=-;sy=-;}
  28. }T[MAXN];
  29. struct Ans
  30. {
  31.     double sxiyi;
  32.     double sxi,syi;
  33.     double pox;
  34.     Ans(){sxiyi=sxi=syi=pox=;}
  35. };
  36. Ans GetAns(int k)
  37. {
  38.     Ans rt;
  39.     rt.sxiyi=T[k].mul;
  40.     rt.sxi=T[k].sx;
  41.     rt.syi=T[k].sy;
  42.     rt.pox=T[k].po;
  43.     return rt;
  44. }
  45. void update(int k)
  46. {
  47.     T[k].po=T[ls].po+T[rs].po;
  48.     T[k].mul=T[ls].mul+T[rs].mul;
  49.     T[k].sx=T[ls].sx+T[rs].sx;
  50.     T[k].sy=T[ls].sy+T[rs].sy;
  51. }
  52. void Memset(int k)
  53. {
  54.     T[k].sx=(T[k].siz*(T[k].l+T[k].r))>>;
  55.     T[k].sy=(T[k].siz*(T[k].l+T[k].r))>>;
  56.     T[k].mul=(T[k].r*(T[k].r+)*(*T[k].r+))/-(T[k].l*(T[k].l-)*(*T[k].l-))/;
  57.     T[k].po=(T[k].r*(T[k].r+)*(*T[k].r+))/-(T[k].l*(T[k].l-)*(*T[k].l-))/;
  58.     T[k].ax=T[k].ay=;
  59.     T[k].lazy=;
  60. }
  61. void Clear(int k,int S,int TT)
  62. {
  63.     T[k].po=T[k].po + 2.0*S*T[k].sx + T[k].siz*S*S;
  64.     T[k].mul=T[k].mul + TT*T[k].sx + S*T[k].sy + T[k].siz*S*TT;
  65.     T[k].sx=T[k].sx + T[k].siz*S;
  66.     T[k].sy=T[k].sy + T[k].siz*TT;
  67.     T[k].ax+=S;
  68.     T[k].ay+=TT;
  69. }
  70. void pushdown(int k)
  71. {
  72.     if(T[k].lazy)
  73.     {
  74.         Memset(ls);
  75.         Memset(rs);
  76.         T[k].lazy=;
  77.         return ;
  78.     }
  79.     int S=T[k].ax,TT=T[k].ay;
  80.     Clear(ls,S,TT);
  81.     Clear(rs,S,TT);
  82.     T[k].ax=;
  83.     T[k].ay=;
  84. }
  85. void Build(int ll,int rr,int k)
  86. {
  87.     T[k].l=ll;T[k].r=rr;
  88.     T[k].siz=rr-ll+;
  89.     if(ll==rr)
  90.     {
  91.         if(T[k].sx==-) {T[k].sx=read();return ;}
  92.         T[k].sy=read();
  93.         T[k].po=T[k].sx*T[k].sx;
  94.         T[k].mul=T[k].sx*T[k].sy;
  95.         return ;
  96.     }
  97.     int mid=ll+rr>>;
  98.     Build(ll,mid,ls);
  99.     Build(mid+,rr,rs);
  100.     update(k);
  101. }
  102. Ans Query(int k,int ll,int rr)
  103. {
  104.     pushdown(k);
  105.     Ans rt;
  106.     if(ll<=T[k].l&&T[k].r<=rr)
  107.     {
  108.         rt=GetAns(k);
  109.         return rt;
  110.     }
  111.     pushdown(k);
  112.     int mid=T[k].l+T[k].r>>;
  113.     if(ll<=mid)
  114.     {
  115.         pushdown(ls);
  116.         Ans Q=Query(ls,ll,rr);
  117.         rt.sxiyi+=Q.sxiyi;
  118.         rt.sxi+=Q.sxi;
  119.         rt.syi+=Q.syi;
  120.         rt.pox+=Q.pox;
  121.     }
  122.     if(rr>mid)
  123.     {
  124.         pushdown(rs);
  125.         Ans Q=Query(rs,ll,rr);
  126.         rt.sxiyi+=Q.sxiyi;
  127.         rt.sxi+=Q.sxi;
  128.         rt.syi+=Q.syi;
  129.         rt.pox+=Q.pox;
  130.     }
  131.     return rt;
  132. }
  133. void IntervalAdd(int k,int ll,int rr,int S,int TT)
  134. {
  135.     pushdown(k);
  136.     if(ll<=T[k].l&&T[k].r<=rr)
  137.     {
  138.         Clear(k,S,TT);
  139.         return ;
  140.     }
  141.     pushdown(k);
  142.     int mid=T[k].l+T[k].r>>;
  143.     if(ll<=mid) pushdown(ls),IntervalAdd(ls,ll,rr,S,TT);
  144.     if(rr>mid)  pushdown(rs),IntervalAdd(rs,ll,rr,S,TT);
  145.     update(k);
  146. }
  147. void IntervalMemset(int k,int ll,int rr)
  148. {
  149.     pushdown(k);
  150.     if(ll<=T[k].l&&T[k].r<=rr)
  151.     {
  152.         Memset(k);
  153.         return ;
  154.     }
  155.     pushdown(k);
  156.     int mid=T[k].l+T[k].r>>;
  157.     if(ll<=mid) pushdown(ls),IntervalMemset(ls,ll,rr);
  158.     if(rr>mid)    pushdown(rs),IntervalMemset(rs,ll,rr);
  159.     update(k);
  160. }
  161. main()
  162. {
  163.     #ifdef WIN32
  164.     freopen("a.in","r",stdin);
  165.     //freopen("c.out","w",stdout);
  166.     #else
  167.     #endif
  168.     int N=read(),M=read();
  169.     Build(,N,);
  170.     Build(,N,);
  171.     while(M--)
  172.     {
  173.         int opt=read();
  174.         if(opt==)
  175.         {
  176.             int L=read(),R=read();
  177.             Ans ans=Query(,L,R);
  178.             double xba=(double)ans.sxi/(double)(R-L+);
  179.             double yba=(double)ans.syi/(double)(R-L+);
  180.             double up=ans.sxiyi-(double)yba*ans.sxi-(double)xba*ans.syi + (double)xba*yba*(R-L+);
  181.             double down=ans.pox - (double)2.0*xba*ans.sxi + (double)xba*xba*(R-L+);
  182.             printf("%.10lf\n",up/down);
  183.         }
  184.         else if(opt==)
  185.         {
  186.             int L=read(),R=read(),S=read(),TT=read();
  187.             IntervalAdd(,L,R,S,TT);
  188.         }
  189.         else if(opt==)
  190.         {
  191.             int L=read(),R=read(),S=read(),TT=read();
  192.             IntervalMemset(,L,R);
  193.             IntervalAdd(,L,R,S,TT);
  194.         }
  195.     }
  196.     return ;
  197. }

稍微整理了一下

  1. #include<cstdio>
  2. #include<queue>
  3. #include<cstring>
  4. #define int long long
  5. #define ls k<<1
  6. #define rs k<<1|1
  7. #define INF 1e8+10
  8. using namespace std;
  9. const int MAXN=1e6+;
  10. //#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,MAXN,stdin),p1==p2)?EOF:*p1++)
  11. inline int read()
  12. {
  13.     char c=getchar();int x=,f=;
  14.     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
  15.     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
  16.     return x*f;
  17. }
  18. struct node
  19. {
  20.     int l,r,siz;
  21.     double po;//x^2
  22.     double mul;//xi*yi
  23.     double sx,sy;//sigma
  24.     double ax,ay;//add
  25.     bool lazy;//memset
  26.     node(){sx=-;sy=-;}
  27. }T[MAXN];
  28. struct Ans
  29. {
  30.     double sxiyi;
  31.     double sxi,syi;
  32.     double pox;
  33.     Ans(){sxiyi=sxi=syi=pox=;}
  34. };
  35. Ans GetAns(int k)
  36. {
  37.     Ans rt;
  38.     rt.sxiyi=T[k].mul;
  39.     rt.sxi=T[k].sx;
  40.     rt.syi=T[k].sy;
  41.     rt.pox=T[k].po;
  42.     return rt;
  43. }
  44. void update(int k)
  45. {
  46.     T[k].po=T[ls].po+T[rs].po;
  47.     T[k].mul=T[ls].mul+T[rs].mul;
  48.     T[k].sx=T[ls].sx+T[rs].sx;
  49.     T[k].sy=T[ls].sy+T[rs].sy;
  50. }
  51. void pushdown(int k)
  52. {
  53.     if(T[k].lazy)
  54.     {
  55.         T[ls].sx=(T[ls].siz*(T[ls].l+T[ls].r))>>;
  56.         T[ls].sy=(T[ls].siz*(T[ls].l+T[ls].r))>>;
  57.         T[ls].mul=(T[ls].r*(T[ls].r+)*(*T[ls].r+))/-(T[ls].l*(T[ls].l-)*(*T[ls].l-))/;
  58.         T[ls].po=(T[ls].r*(T[ls].r+)*(*T[ls].r+))/-(T[ls].l*(T[ls].l-)*(*T[ls].l-))/;
  59.         T[ls].ax=T[ls].ay=;
  60.         T[ls].lazy=;
  61.         T[rs].sx=(T[rs].siz*(T[rs].l+T[rs].r))>>;
  62.         T[rs].sy=(T[rs].siz*(T[rs].l+T[rs].r))>>;
  63.         T[rs].mul=(T[rs].r*(T[rs].r+)*(*T[rs].r+))/-(T[rs].l*(T[rs].l-)*(*T[rs].l-))/;
  64.         T[rs].po=(T[rs].r*(T[rs].r+)*(*T[rs].r+))/-(T[rs].l*(T[rs].l-)*(*T[rs].l-))/;
  65.         T[rs].ax=T[rs].ay=;
  66.         T[rs].lazy=;
  67.         T[k].lazy=;
  68.         return ;
  69.     }
  70.     int S=T[k].ax,TT=T[k].ay;
  71.     T[ls].po=T[ls].po+ 2.0*S*T[ls].sx + T[ls].siz*S*S;
  72.     T[ls].mul=T[ls].mul + TT*T[ls].sx + S*T[ls].sy + T[ls].siz*S*TT;
  73.     T[ls].sx=T[ls].sx + T[ls].siz*S;
  74.     T[ls].sy=T[ls].sy + T[ls].siz*TT;
  75.     T[ls].ax+=S;
  76.     T[ls].ay+=TT;
  77.     T[rs].po=T[rs].po+ 2.0*S*T[rs].sx + T[rs].siz*S*S;
  78.     T[rs].mul=T[rs].mul + TT*T[rs].sx + S*T[rs].sy + T[rs].siz*S*TT;
  79.     T[rs].sx=T[rs].sx + T[rs].siz*S;
  80.     T[rs].sy=T[rs].sy + T[rs].siz*TT;
  81.     T[rs].ax+=S;
  82.     T[rs].ay+=TT;
  83.     T[k].ax=;
  84.     T[k].ay=;
  85. }
  86. void Build(int ll,int rr,int k)
  87. {
  88.     T[k].l=ll;T[k].r=rr;
  89.     T[k].siz=rr-ll+;
  90.     if(ll==rr)
  91.     {
  92.         if(T[k].sx==-) {T[k].sx=read();return ;}
  93.         T[k].sy=read();
  94.         T[k].po=T[k].sx*T[k].sx;
  95.         T[k].mul=T[k].sx*T[k].sy;
  96.         return ;
  97.     }
  98.     int mid=ll+rr>>;
  99.     Build(ll,mid,ls);
  100.     Build(mid+,rr,rs);
  101.     update(k);
  102. }
  103. Ans Query(int k,int ll,int rr)
  104. {
  105.     pushdown(k);
  106.     Ans rt;
  107.     if(ll<=T[k].l&&T[k].r<=rr)
  108.     {
  109.         rt=GetAns(k);
  110.         return rt;
  111.     }
  112.     pushdown(k);
  113.     int mid=T[k].l+T[k].r>>;
  114.     if(ll<=mid)
  115.     {
  116.         pushdown(ls);
  117.         Ans Q=Query(ls,ll,rr);
  118.         rt.sxiyi+=Q.sxiyi;
  119.         rt.sxi+=Q.sxi;
  120.         rt.syi+=Q.syi;
  121.         rt.pox+=Q.pox;
  122.     }
  123.     if(rr>mid)
  124.     {
  125.         pushdown(rs);
  126.         Ans Q=Query(rs,ll,rr);
  127.         rt.sxiyi+=Q.sxiyi;
  128.         rt.sxi+=Q.sxi;
  129.         rt.syi+=Q.syi;
  130.         rt.pox+=Q.pox;
  131.     }
  132.     return rt;
  133. }
  134. void IntervalAdd(int k,int ll,int rr,int S,int TT)
  135. {
  136.     pushdown(k);
  137.     if(ll<=T[k].l&&T[k].r<=rr)
  138.     {
  139.         T[k].po=T[k].po + 2.0*S*T[k].sx + T[k].siz*S*S;
  140.         T[k].mul=T[k].mul + TT*T[k].sx + S*T[k].sy + T[k].siz*S*TT;
  141.         T[k].sx=T[k].sx + T[k].siz*S;
  142.         T[k].sy=T[k].sy + T[k].siz*TT;
  143.         T[k].ax+=S;
  144.         T[k].ay+=TT;
  145.         return ;
  146.     }
  147.     pushdown(k);
  148.     int mid=T[k].l+T[k].r>>;
  149.     if(ll<=mid) pushdown(ls),IntervalAdd(ls,ll,rr,S,TT);
  150.     if(rr>mid)  pushdown(rs),IntervalAdd(rs,ll,rr,S,TT);
  151.     update(k);
  152. }
  153. void IntervalMemset(int k,int ll,int rr)
  154. {
  155.     pushdown(k);
  156.     if(ll<=T[k].l&&T[k].r<=rr)
  157.     {
  158.         T[k].sx=(T[k].siz*(T[k].l+T[k].r))>>;
  159.         T[k].sy=(T[k].siz*(T[k].l+T[k].r))>>;
  160.         T[k].mul=(T[k].r*(T[k].r+)*(*T[k].r+))/-(T[k].l*(T[k].l-)*(*T[k].l-))/;
  161.         T[k].po=(T[k].r*(T[k].r+)*(*T[k].r+))/-(T[k].l*(T[k].l-)*(*T[k].l-))/;
  162.         T[k].ax=T[k].ay=;
  163.         T[k].lazy=;
  164.         return ;
  165.     }
  166.     pushdown(k);
  167.     int mid=T[k].l+T[k].r>>;
  168.     if(ll<=mid) pushdown(ls),IntervalMemset(ls,ll,rr);
  169.     if(rr>mid)    pushdown(rs),IntervalMemset(rs,ll,rr);
  170.     update(k);
  171. }
  172. main()
  173. {
  174.     #ifdef WIN32
  175.     freopen("a.in","r",stdin);
  176.     freopen("c.out","w",stdout);
  177.     #else
  178.     #endif
  179.     int N=read(),M=read();
  180.     Build(,N,);
  181.     Build(,N,);
  182.     while(M--)
  183.     {
  184.         int opt=read();
  185.         if(opt==)
  186.         {
  187.             int L=read(),R=read();
  188.             Ans ans=Query(,L,R);
  189.             double xba=(double)ans.sxi/(double)(R-L+);
  190.             double yba=(double)ans.syi/(double)(R-L+);
  191.             double up=ans.sxiyi-(double)yba*ans.sxi-(double)xba*ans.syi + (double)xba*yba*(R-L+);
  192.             double down=ans.pox - (double)2.0*xba*ans.sxi + (double)xba*xba*(R-L+);
  193.             printf("%.10lf\n",up/down);
  194.         }
  195.         else if(opt==)
  196.         {
  197.             int L=read(),R=read(),S=read(),TT=read();
  198.             IntervalAdd(,L,R,S,TT);
  199.         }
  200.         else if(opt==)
  201.         {
  202.             int L=read(),R=read(),S=read(),TT=read();
  203.             IntervalMemset(,L,R);
  204.             IntervalAdd(,L,R,S,TT);
  205.         }
  206.     }
  207.     return ;
  208. }

洛谷P3707 [SDOI2017]相关分析(线段树)的更多相关文章

  1. [Sdoi2017]相关分析 [线段树]

    [Sdoi2017]相关分析 题意:沙茶线段树 md其实我考场上还剩一个多小时写了40分 其实当时写正解也可以吧1h也就写完了不过还要拍一下 正解代码比40分短2333 #include <io ...

  2. 【BZOJ】1012: [JSOI2008]最大数maxnumber /【洛谷】1198（线段树）

    Description 现在请求你维护一个数列,要求提供以下两种操作:1. 查询操作.语法:Q L 功能:查询当前数列中末尾L个数中的最大的数,并输出这个数的值.限制:L不超过当前数列的长度.2. 插 ...

  3. 【BZOJ4821】[Sdoi2017]相关分析 线段树

    [BZOJ4821][Sdoi2017]相关分析 Description Frank对天文学非常感兴趣,他经常用望远镜看星星,同时记录下它们的信息,比如亮度.颜色等等,进而估算出星星的距离,半径等等. ...

  4. 洛谷题解P4314CPU监控--线段树

    题目链接 https://www.luogu.org/problemnew/show/P4314 https://www.lydsy.com/JudgeOnline/problem.php?id=30 ...

  5. 洛谷P3372/poj3468（线段树lazy_tag）（询问区间和，支持区间修改）

    洛谷P3372 //线段树 询问区间和,支持区间修改 #include <cstdio> using namespace std; struct treetype { int l,r; l ...

  6. 洛谷P4065 [JXOI2017]颜色(线段树)

    题意 题目链接 Sol 线段树板子题都做不出来,真是越来越菜了.. 根据题目描述,一个合法区间等价于在区间内的颜色没有在区间外出现过. 所以我们可以对于每个右端点,统计最长的左端点在哪里,刚开始以为这 ...

  7. 洛谷P5111 zhtobu3232的线段树

    题意:给定线段树,上面若干个节点坏了,求能表示出多少区间. 区间能被表示出当且仅当拆出来的log个节点都是好的. 解:每个区间在最浅的节点处计算答案. 对于每个节点维护从左边过来能有多少区间,从右边过 ...

  8. BZOJ.4821.[SDOI2017]相关分析(线段树)

    BZOJ LOJ 洛谷 恶心的拆式子..然后就是要维护\(\sum x_i,\ \sum y_i,\ \sum x_iy_i,\ \sum x_i^2\). 操作三可以看成初始化一遍,然后同操作二. ...

  9. 洛谷P3960 列队 NOIp2017 线段树/树状数组/splay

    正解:动态开点线段树 解题报告: 传送门! 因为最近学主席树的时候顺便get到了动态开点线段树?刚好想起来很久很久以前就想做结果一直麻油做的这题,,,所以就做下好了QAQ 然后说下,这题有很多种方法, ...

随机推荐

  1. CV/PR:模式识别与图像处理笔试题

    汉王高级研究人员(模式识别.图像处理类)招聘试题  原文链接:http://www.cnblogs.com/dongsheng/articles/2793142.html 说明:  可能您的专业并不完 ...

  2. Approximate Nearest Neighbors.接近最近邻搜索

    (一):次优最近邻:http://en.wikipedia.org/wiki/Nearest_neighbor_search 有少量修改:如有疑问,请看链接原文.....1.Survey:Neares ...

  3. sqlserver 分组 group by

    select 名称, COUNT(名称) as 数量之和from 信息group by all 名称

  4. C#结束Explorer进程

    private void Form1_Load(object sender, EventArgs e) { Process[] processes = Process.GetProcesses();/ ...

  5. JavaScript回顾一下js的基础知识，以及学习一下在项目中了解到的新知识

    学习文档:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Functions https://www.cnblogs.com ...

  6. 沃通SSL证书、代码签名证书应用于机器人安全防护

    近两年,扫地机器人.智能音箱等消费级机器人产品逐渐走入大众生活的中.随着人工智能技术的迅猛发展,预计2023年全球消费级机器人市场规模将达到150亿美元.然而,产业的迅猛发展却伴随着安全防护的缺失,安 ...

  7. Python笔记9-----不等长列表转化成DataFrame

    1.不同长度的列表合并成DataFrame. 法1: ntest=['a','b'] ltest=[[1,2],[4,5,6]] 先变成等长的列表:(a:1),(a:2),(b:4),(b:5),(b ...

  8. C语言基础 (5) 常用操作符

    01 课程回顾 变量的起名:字母数字下划线 不能是关键字 常量 变量提升:老的编译器这样会报错 运算符:sizeof.+.-.x … … 进制: 1111 8421 计算机几乎都是二进制系统,而且是以 ...

  9. POJ2406A- Power Strings

    Given two strings a and b we define a*b to be their concatenation. For example, if a = "abc&quo ...

  10. python开发项目：学生选课系统

    程序要求:1.创建北京.上海两所学校(分析:通过学校类实例化两个学校实例) 2.创建Linux.python.go三个课程,Linux\go在北京开,Linux在上海开(创建Linux.python. ...