前言
我是照着老师讲的+这篇博客思路打的…
某大佬的blog
题目
给出
,一个随机的
的排列,现在所有奇数位上有记号,有记号的格子数一开始会自动排序,现在你能从相邻的逆序对随机选择一对交换
问排好序的步数的期望和方差?
增加区间修改操作(修改格子上的记号),每次修改后询问步数的期望?
思路
发现你选择交换相邻逆序对顺序对答案无影响,每次操作答案即为逆序对个数,
是否为逆序对独立,于是:
根据期望线性性可得:
考虑对 (i<j) 的计算:
-
均无标记
由于随机, -
均有标记
-
有,
没有
似乎有点难,设有 个数打标记, 是第 个数打了标记,我们可以考虑为在有 个球的盒子里面抓 个球排好序后随机指定一个为 所抓的,得出概率为 -
有,
没有
同理 可得概率为
那么考虑计算刚开始的期望:
- 长度为偶数
- 长度为奇数
(真TM难算)
考虑方差计算:
我们只需要算
即可…
真的不会啊,这
的分布函数咋求?
好像是利用拉格朗日插值打表
就当这道题练期望吧
方差答案:
长度为偶数 :
长度为奇数 :
考虑修改操作,情况 通过简单的区间操作求出,对于情况 考虑每一个未标记位置 对答案的贡献:
-
,
被标记
设 前面有 个位置被标记,当前总标记为
那么 对答案的贡献为
然后就是高端操作了…
难点在计算
发现
记标记位置为 ,没有为 ,实际上统计 和 的个数 -
,
被标记
差不多,设 后面有 个位置被标记
那么 对答案的贡献为
即统计 和 的个数
线段树即可 通过统计 个数能求出
代码
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<cstring>
#include<climits>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define LL long long
//#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
//char buf[(1 << 21) + 1], *p1 = buf, *p2 = buf;
inline int read() {
bool f=0;int x=0;char c=getchar();
while(c<'0'||'9'<c){if(c==EOF)exit(0);if(c=='-')f=1;c=getchar();}
while('0'<=c&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
return !f?x:-x;
}
#define MAXN 100000
#define INF 0x3f3f3f3f
LL gcd(LL a,LL b){return !b?a:gcd(b,a%b);}
struct node{
int l,r,lazy;
LL cnt_0,cnt_1,cnt_01,cnt_10,cnt_011,cnt_110;
friend node operator + (node a,node b){
node c;
c.l=a.l,c.r=b.r,c.lazy=-1;
c.cnt_0=a.cnt_0+b.cnt_0;
c.cnt_1=a.cnt_1+b.cnt_1;
c.cnt_01=a.cnt_01+b.cnt_01+a.cnt_0*b.cnt_1;
c.cnt_10=a.cnt_10+b.cnt_10+a.cnt_1*b.cnt_0;
c.cnt_011=a.cnt_011+b.cnt_011+a.cnt_01*b.cnt_1+a.cnt_0*b.cnt_1*(b.cnt_1-1)/2;
c.cnt_110=a.cnt_110+b.cnt_110+a.cnt_1*b.cnt_10+a.cnt_1*(a.cnt_1-1)/2*b.cnt_0;
return c;
}
}tree[5*MAXN+5];
#define lch (u<<1)
#define rch (u<<1|1)
void PushUp(int u){
tree[u]=tree[lch]+tree[rch];
return ;
}
void PushDown(int u,int L,int Mid,int R){
if(tree[u].lazy==-1) return ;
tree[lch]=(node){L,Mid,tree[u].lazy,(Mid-L+1)*(tree[u].lazy^1),(Mid-L+1)*tree[u].lazy,0,0,0,0};
tree[rch]=(node){Mid+1,R,tree[u].lazy,(R-Mid)*(tree[u].lazy^1),(R-Mid)*tree[u].lazy,0,0,0,0};
tree[u].lazy=-1;
return ;
}
void Build(int u,int L,int R){
if(L==R){
tree[u]=(node){L,R,-1,(L&1)^1,(L&1),0,0,0,0};
return ;
}
int Mid=(L+R)>>1;
Build(lch,L,Mid),Build(rch,Mid+1,R);
PushUp(u);
return ;
}
void Modify(int u,int L,int R,int qL,int qR,int v){
if(qL<=L&&R<=qR){
tree[u]=(node){L,R,v,(R-L+1)*(v^1),(R-L+1)*v,0,0,0,0};
return ;
}
int Mid=(L+R)>>1;
PushDown(u,L,Mid,R);
if(qL<=Mid)
Modify(lch,L,Mid,qL,qR,v);
if(Mid+1<=qR)
Modify(rch,Mid+1,R,qL,qR,v);
PushUp(u);
return ;
}
int main(){
LL n=read(),x=n/2,m=read();
if(n&1){
LL p=7*x*x+x,q=12,g=gcd(p,q);
printf("%lld/%lld\n",p/g,q/g);
p=54*x*x*x+55*x*x-29*x,q=360,g=gcd(p,q);
printf("%lld/%lld\n",p/g,q/g);
}
else{
LL p=7*x*x-x,q=12,g=gcd(p,q);
printf("%lld/%lld\n",p/g,q/g);
p=54*x*x*x+13*x*x+23*x,q=360,g=gcd(p,q);
printf("%lld/%lld\n",p/g,q/g);
}
Build(1,1,n);
for(int i=1;i<=m;i++){
int l=read(),r=read(),v=read();
Modify(1,1,n,l,r,v);
node Rt=tree[1];
LL p1=Rt.cnt_01+Rt.cnt_011+Rt.cnt_10+Rt.cnt_110,q1=Rt.cnt_1+1;
LL p2=Rt.cnt_0*(Rt.cnt_0-1),q2=4;
LL p=p1*q2+p2*q1,q=q1*q2,g=gcd(p,q);
printf("%lld/%lld\n",p/g,q/g);
}
return 0;
}
题外话
CF的k不相交子段和的18个变量教会我做人,这题实际做法跟那道比起来太简单了…