SDOI2017 解题报告

数字表格

\(T\)次询问，每次给出\(n,m(n,m\le 10^6)\)，\(f\)为斐波那契数列，\(f_0=0,f_1=1\)，求：

\[\prod _{i=1}^n\prod _{j=1}^mf[gcd(i,j)]
\]

题解做法

这个题的思路很妙啊。

看到那个\(gcd\)，又注意到前面是个连乘，我们可以构造函数\(g(x)\)，使得：

\[f(x)=\prod _{d|x}g(d)
\]

那么：

\[\begin{aligned}
ans&=\prod _{i=1}^n\prod _{j=1}^m\prod _{d|i,d|j}g(d) \\
&=\prod _{d=1}^ng(d)^{\lfloor \frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor}
\end{aligned}
\]

分段计算即可。

\(g\)的求法很简单：

\[g(x)=\frac{f(x)}{\prod {_{d|x,d\ne x}g(d)}}
\]

预处理复杂度为\(O(n\sqrt n+nlogn)\)，询问总复杂度为\(O(Tn(\sqrt n+\sqrt m))\)。

想法

其实这个东西如果想不到，还有一个方向可以走：

\[\begin{aligned}
ans&=\prod _{i=1}^n\prod _{j=1}^mf[gcd(i,j)] \\
&=\prod _{d=1}^nf_d^{\prod _{i=1}^{\lfloor\frac{n}{d}\rfloor}\prod _{j=1}^{\lfloor \frac{m}{d}\rfloor}[gcd(i,j)=1]} \\
&=\prod _{d=1}^nf_d^{\prod _{i=1}^{\lfloor\frac{n}{d}\rfloor}\prod _{j=1}^{\lfloor \frac{m}{d}\rfloor}\prod _{k|i,k|j}\mu (k)} \\
&=\prod _{d=1}^nf_d^{\prod _{k=1}^{\lfloor\frac{n}{d}\rfloor}\mu (k)\lfloor\frac{n}{kd}\rfloor\lfloor\frac{m}{kd}\rfloor} \\
令t&=kd \\
ans&=\prod _{t=1}^n\prod _{k|t}f_k^{\mu (\frac{t}{k})\lfloor\frac{n}{t}\rfloor\lfloor\frac{m}{t}\rfloor}
\end{aligned}
\]

同样可以分段计算。其实上面的\(g\)就是下面的$$\prod _{k|t}f_k^{\mu (\frac{t}{k})}$$。

这就是连乘意义下的莫比乌斯反演：

\[f(n)=\prod _{d|n}g(d) \Leftrightarrow g(n)=\prod _{d|n}f(d)^{\mu (\frac{n}{d})}
\]

两边取对数即得证。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long giant;
int read() {
	int x=0,f=1;
	char c=getchar();
	for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
	for (;isdigit(c);c=getchar()) x=x*10+c-'0';
	return x*f;
}
const int maxn=1e6+1;
const int q=1e9+7;
int f[maxn],g[maxn],iv[maxn],ig[maxn];
int multi(int x,int y) {
	return (giant)x*y%q;
}
int Plus(int x,int y) {
	return ((giant)x+y)%q;
}
int mi(int x,int y) {
	int ret=1;
	for (;y;y>>=1,x=multi(x,x)) if (y&1) ret=multi(ret,x);
	return ret;
}
int inv(int x) {
	return mi(x,q-2);
}
int pre[maxn],ipre[maxn];
int main() {
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
#endif
	iv[1]=1;
	for (int i=2;i<maxn;++i) iv[i]=q-multi(iv[q%i],q/i);
	f[0]=0,f[1]=g[1]=ig[1]=1;
	for (int i=2;i<maxn;++i) {
		f[i]=Plus(f[i-1],f[i-2]);
		int &in=ig[i]=1;
		for (int j=1;j*j<=i;++j) if (i%j==0) {
			in=multi(in,ig[j]);
			if (j*j!=i) in=multi(in,ig[i/j]);
		}
		g[i]=multi(f[i],in);
		in=inv(g[i]);
	}
	pre[0]=ipre[0]=1;
	for (int i=1;i<maxn;++i) ipre[i]=inv(pre[i]=multi(pre[i-1],g[i]));
	int T=read();
	while (T--) {
		int ret=1,n=read(),m=read();
		if (n>m) swap(n,m);
		for (int l=1,r,c;l<=n;l=r+1) {
			r=min(n/(n/l),m/(m/l));
			int up=(giant)(n/l)%(q-1)*(m/l)%(q-1);
			ret=multi(ret,mi(multi(pre[r],ipre[l-1]),up));
		}
		printf("%d\n",ret);
	}
	return 0;
}

树点涂色

给出一颗\(n\)个点1为根的树，初始时每个点都有个不一样的颜色。我们定义一条路径的权值为路径上不同颜色的个数。有三个操作：

• 将一个点到根的的路径上的所有点都染成一个新的颜色
• 询问一条路径\((x,y)\)的权值
• 询问一个点的子树中所有点，他们到根路径的权值最大的那个

\(n,m\le 10^5\)。

分析

这个问题也很巧妙！我们注意到每次操作都修改一个点到根路径上的所有点，每次的颜色都是新的，这就可以发现和link-cut tree的access操作很像。并且有一个性质，由于每次修改都是修改到根的路径，并且都变成新的颜色，所以颜色一定是竖直链状的。这样我们可以想到，如果对每个点维护一个\(f\)值，如果它的颜色与父亲一样，那么这个值为1，否则为0，那么一个点到根路径的权值就是根到这个点路径上的所有点的\(f\)值和，我们称它为\(g\)。

我们可以用线段树来维护这个东西，由于询问中有子树询问，所以就使用dfs序的线段树。每次修改用一个access操作，每断掉一条虚边，我们就把这个虚子树的所有点的\(g\)值加1，表示下面的点到根路径上多了一种颜色；每连上一条实边，我们就把这个子树的所有点\(g\)值减1。这样层层往上，我们就可以维护所有点的\(g\)信息了。

询问路径\((x,y)\)的权值，设\(x,y\)的\(\text{lca}\)为\(l\)，那么答案就是\(g_x+g_y-2g_l+1\)，想象一下这个情况就知道它减掉两倍\(g_l\)会少掉一种颜色，所以要补回来。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
int read() {
	int x=0,f=1;
	char c=getchar();
	for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
	for (;isdigit(c);c=getchar()) x=x*10+c-'0';
	return x*f;
}
const int maxn=1e5+10;
const int maxj=17;
struct edge {
	int v,nxt;
} e[maxn<<2];
int h[maxn],tot=0;
int f[maxn][maxj],dep[maxn],first[maxn],second[maxn],dft=0,n;
int inv[maxn];
void add(int u,int v) {
	e[++tot]=(edge){v,h[u]};
	h[u]=tot;
}
int lca(int x,int y) {
	if (dep[x]<dep[y]) swap(x,y);
	for (int j=maxj-1;j>=0;--j) if (dep[f[x][j]]>=dep[y]) x=f[x][j];
	if (x==y) return x;
	for (int j=maxj-1;j>=0;--j) if (f[x][j]!=f[y][j]) x=f[x][j],y=f[y][j];
	return f[x][0];
}
struct SGT {
	int t[maxn<<2],tag[maxn<<2];
	void update(int x) {
		t[x]=max(t[x<<1],t[x<<1|1]);
	}
	void build(int x,int l,int r) {
		if (l==r) {
			t[x]=dep[inv[l]];
			tag[x]=0;
			return;
		}
		int mid=l+r>>1;
		build(x<<1,l,mid);
		build(x<<1|1,mid+1,r);
		update(x);
	}
	void doit(int x,int d) {
		t[x]+=d;
		tag[x]+=d;
	}
	void pushdown(int x) {
		doit(x<<1,tag[x]);
		doit(x<<1|1,tag[x]);
		update(x);
		tag[x]=0;
	}
	void add(int x,int L,int R,int l,int r,int d) {
		if (L==l && R==r) {
			doit(x,d);
			return;
		}
		int mid=L+R>>1;
		pushdown(x);
		if (r<=mid) add(x<<1,L,mid,l,r,d); else
		if (l>mid) add(x<<1|1,mid+1,R,l,r,d); else
		add(x<<1,L,mid,l,mid,d),add(x<<1|1,mid+1,R,mid+1,r,d);
		update(x);
	}
	int query(int x,int L,int R,int l,int r) {
		if (L==l && R==r) return t[x];
		pushdown(x);
		int mid=L+R>>1;
		if (r<=mid) return query(x<<1,L,mid,l,r);
		if (l>mid) return query(x<<1|1,mid+1,R,l,r);
		return max(query(x<<1,L,mid,l,mid),query(x<<1|1,mid+1,R,mid+1,r));
	}
	int one(int p) {
		p=first[p];
		return query(1,1,n,p,p);
	}
} sgt;
struct node {
	int ch[2],fa;
};
struct LCT {
	node t[maxn];
	void link(int x,int y) {
		t[y].fa=x;
	}
	int left(int x) {
		while (t[x].ch[0]) x=t[x].ch[0];
		return x;
	}
	bool isroot(int x) {
		return !x || t[t[x].fa].ch[rson(x)]!=x;
	}
	bool rson(int x) {
		return t[t[x].fa].ch[1]==x;
	}
	void rotate(int x) {
		int f=t[x].fa,d=rson(x),c=t[x].ch[d^1];
		if (!isroot(f)) t[t[f].fa].ch[rson(f)]=x;
int inv[maxn];
		if (c) t[c].fa=f;
		t[x].fa=t[f].fa,t[f].fa=x,t[x].ch[d^1]=f,t[f].ch[d]=c;
	}
	void splay(int x) {
		while (!isroot(x)) {
			if (isroot(t[x].fa)) rotate(x); else {
				if (rson(x)==rson(t[x].fa)) rotate(t[x].fa),rotate(x); else
				rotate(x),rotate(x);
			}
		}
	}
	void access(int x) {
		for (int last=0;x;x=t[last=x].fa) {
			splay(x);
			int p=t[x].ch[1]?left(t[x].ch[1]):0;
			if (p) sgt.add(1,1,n,first[p],second[p],1);
			t[x].ch[1]=last;
			p=t[x].ch[1]?left(t[x].ch[1]):0;
			if (p) sgt.add(1,1,n,first[p],second[p],-1);
		}
	}
} lct;
void dfs(int x,int fa) {
	inv[first[x]=++dft]=x;
	f[x][0]=fa;
	if (x==fa) dep[x]=1; else dep[x]=dep[fa]+1,lct.link(fa,x);
	for (int i=h[x],v=e[i].v;i;i=e[i].nxt,v=e[i].v) if (v!=fa) dfs(v,x);
	second[x]=dft;
}
int line(int x,int y) {
	int l=lca(x,y);
	int fx=sgt.one(x),fy=sgt.one(y),fl=sgt.one(l);
	return fx+fy-fl-fl+1;
}
int sub(int x) {
	int ret=sgt.query(1,1,n,first[x],second[x]);
	return ret;
}
int main() {
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("my.out","w",stdout);
#endif
	n=read();
	int m=read();
	for (int i=2;i<=n;++i) {
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dfs(1,1);
	for (int j=1;j<maxj;++j) for (int i=1;i<=n;++i) f[i][j]=f[f[i][j-1]][j-1];
	sgt.build(1,1,n);
	while (m--) {
		int op=read();
		if (op==1) {
			int x=read();
			lct.access(x);
		} else if (op==2) {
			int x=read(),y=read();
			int ans=line(x,y);
			printf("%d\n",ans);
		} else if (op==3) {
			int x=read();
			int ans=sub(x);
			printf("%d\n",ans);
		}
	}
	return 0;
}

序列计数

有多少长度为\(n\)，其中的数都小于等于\(m\)，和模\(p\)为0，且至少含有一个质数的数列？

\(n\le 10^9,m\le 2\times 10^7,p\le 100\)。

分析

至少含有一个质数的数列，就是随便乱选的数列个数减去不含质数的数列个数。对于一些可选的数，由于选的次数不限，所以每次我们都可以从当前的选法加上一个数，即\(f_{ij}\)表示选了\(i\)个数，当前模\(p\)为\(j\)的方案数，每次通过一个固定的线性转移转移过去。所以可以用矩阵乘法优化解决。我写的是生成函数的方法，本质和矩阵是一样的。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long giant;
const int q=20170408;
int multi(int x,int y) {
	return ((giant)x*y)%q;
}
int Plus(int x,int y) {
	return ((giant)x+y)%q;
}
int sub(int x,int y) {
	return Plus(x,q-y);
}
const int maxn=250;
int a[maxn],b[maxn],n,m,p,c[maxn];
void mul(int a[],int b[]) {
	memset(c,0,sizeof c);
	for (int i=0;i<p;++i) for (int j=0;j<p;++j) c[(i+j)%p]=Plus(c[(i+j)%p],multi(a[i],b[j]));
	for (int i=0;i<p;++i) a[i]=c[i];
}
int first() {
	memset(b,0,sizeof b),b[0]=1;
	memset(a,0,sizeof a);
	for (int i=1;i<=m;++i) ++a[i%p];
	int y=n;
	for (;y;y>>=1,mul(a,a)) if (y&1)
		mul(b,a);
	return b[0];
}
const int maxm=2e7+1;
const int pss=6e6+1;
bool np[maxm];
int pm[pss],ps=0;
int second() {
	np[1]=true;
	for (int i=2;i<=m;++i) {
		if (!np[i]) pm[++ps]=i;
		for (int j=1;j<=ps && (giant)pm[j]*i<(giant)maxm;++j) {
			int tmp=pm[j]*i;
			np[tmp]=true;
			if (i%pm[j]==0) break;
		}
	}
	memset(b,0,sizeof b),b[0]=1;
	memset(a,0,sizeof a);
	for (int i=1;i<=m;++i) if (np[i]) ++a[i%p];
	int y=n;
	for (;y;y>>=1,mul(a,a)) if (y&1) mul(b,a);
	return b[0];
}
int main() {
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
#endif
	scanf("%d%d%d",&n,&m,&p);
	int f=first();
	int s=second();
	int ans=sub(f,s);
	printf("%d\n",ans);
}

新生舞会

一个二分图匹配，每一个匹配\((i,j)\)有两个属性\(a_{ij},b_{ij}\)，求一个完备匹配，使得：

\[C=\frac{\sum a_i}{\sum b_i}
\]

最大。\(n\le 100\)。

分析

二分答案\(C\)，我们要求的是是否有一种匹配使得\(\frac{\sum a_i}{\sum b_i}\)大于\(C\)，即是否存在一个\(\sum a_i-Cb_i\)大于0的匹配。直接做最大匹配即可，这里用的是KM算法。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<cmath>
#include<queue>
#include<algorithm>
using namespace std;
int read() {
    int x=0,f=1;
    char c=getchar();
    for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
    for (;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}
const double eps=1e-10;
const double up=1e8;
const double inf=1e100;
const int maxn=205;
int a[maxn][maxn],b[maxn][maxn],n,match[maxn],pre[maxn];
double f[maxn][maxn],ex[maxn],ey[maxn],slack[maxn];
bool vy[maxn];
void augment(int now) {
    int y;
    fill(slack,slack+n+1,inf);
    memset(vy,0,sizeof vy);
    match[y=0]=now;
    do {
        vy[y]=true;
        int to,x=match[y];
        double d=inf;
        for (int i=1;i<=n;++i) if (!vy[i]) {
            if (ex[x]+ey[i]-f[x][i]<slack[i]) slack[i]=ex[x]+ey[i]-f[x][i],pre[i]=y;
            if (slack[i]<d) d=slack[i],to=i;
        }
        for (int i=0;i<=n;++i) if (vy[i]) ex[match[i]]-=d,ey[i]+=d; else slack[i]-=d;
        y=to;
    } while (match[y]);
    for (;y;y=pre[y]) match[y]=match[pre[y]];
}
double km() {
    for (int i=1;i<=n;++i)
        augment(i);
    double ret=0;
    for (int i=1;i<=n;++i) ret+=ex[i]+ey[i];
    return ret;
}
bool ok(double c) {
    memset(f,0,sizeof f),memset(ey,0,sizeof ey),memset(match,0,sizeof match),memset(pre,0,sizeof pre);
    for (int i=1;i<=n;++i) for (int j=1;j<=n;++j) f[i][j]=(double)a[i][j]-c*(double)b[i][j];
    for (int i=1;i<=n;++i) for (int j=1;j<=n;++j) ex[i]=(j==1?f[i][j]:max(ex[i],f[i][j]));
    double cost=km();
    return cost>=0;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("test.in","r",stdin);
    freopen("my.out","w",stdout);
#endif
    n=read();
    for (int i=1;i<=n;++i) for (int j=1;j<=n;++j) a[i][j]=read();
    for (int i=1;i<=n;++i) for (int j=1;j<=n;++j) b[i][j]=read();
    double l=0,r=1e4,mid,ans;
    while (fabs(l-r)>eps) {
        mid=(l+r)/2;
        if (ok(mid)) ans=mid,l=mid; else r=mid;
    }
    printf("%.6lf\n",ans);
    return 0;
}

相关分析

\(n,m\le 10^5\)。

分析

这是一个区间修改，区间加法，区间查询奇怪东西的问题，可以看看它要维护的是什么东西，从查询入手。

\[\begin{aligned}
a&=\frac{\sum _{i=L}^R(x_i-\overline x)(y_i-\overline y)}{\sum _{i=L}^R(x_i-\overline x)^2} \\
&=\frac{\sum _{i=L}^Rx_iy_i-\overline x\sum _{i=L}^Ry_i-\overline y\sum _{i=L}^Rx_i+(R-L+1)\overline x\overline y}{\sum _{i=L}^R x_i^2+2\overline x\sum _{i=L}^Rx_i+(R-L+1)\overline x^2}
\end{aligned}
\]

所以维护区间\(x\)，\(y\)，\(xy\)，\(x^2\)的和就好啦，记得修改的优先级比区间加要高。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long giant; // remember to change long long
typedef long double lb;
giant read() {
	giant x=0,f=1;
	char c=getchar();
	for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
	for (;isdigit(c);c=getchar()) x=x*10+c-'0';
	return x*f;
}
const giant maxn=1e5+10;
lb basex[maxn],basey[maxn];
int n;
giant pf[maxn];
struct Data {
	/*
	 * x is the sum of xi in this range
	 * y is the sum of yi in this range
	 * xy is the sum of xi*yi in the range
	 * fang is the sum of xi*xi in this range
	 */
	lb x,y,xy,fang;
	Data (lb x=0,lb y=0,lb xy=0,lb fang=0):x(x),y(y),xy(xy),fang(fang) {}
	void init(lb _x,lb _y) {
		x=_x,y=_y;
		xy=x*y;
		fang=x*x;
	}
};
Data operator + (Data a,Data b) {
	return Data(a.x+b.x,a.y+b.y,a.xy+b.xy,a.fang+b.fang);
}
Data operator += (Data &a,Data b) {
	a=a+b;
}
struct Tag {
	lb s,t;
	int op;
	Tag (lb s=0,lb t=0,int op=0):s(s),t(t),op(op) {}
	void clear() {
		s=t=op=0;
	}
};
Tag operator + (Tag a,Tag b) {
	return Tag(a.s+b.s,a.t+b.t,max(a.op,b.op));
}
struct SGT {
	Data dat[maxn<<3];
	Tag tag[maxn<<3];
	void build(int x,int l,int r) {
		if (l==r) {
			dat[x].init(basex[l],basey[l]);
			tag[x].clear();
			return;
		}
		giant mid=l+r>>1;
		build(x<<1,l,mid);
		build(x<<1|1,mid+1,r);
		dat[x]=dat[x<<1]+dat[x<<1|1];
	}
	void doit(giant x,giant l,giant r,lb s,lb t,int op) {
		if (op==1) {
			Data &d=dat[x];
			d.xy+=t*d.x+s*d.y+(r-l+1)*s*t;
			d.fang+=2*s*d.x+(r-l+1)*s*s;
			d.x+=(r-l+1)*s;
			d.y+=(r-l+1)*t;
			tag[x]=tag[x]+Tag(s,t,op);
		} else if (op==2) {
			Data &d=dat[x];
			giant qj=(l+r)*(r-l+1)/2,f=pf[r]-pf[l-1];
			d.xy=f+qj*(s+t)+(r-l+1)*s*t;
			d.x=qj+(r-l+1)*s;
			d.y=qj+(r-l+1)*t;
			d.fang=f+s*qj*2+(r-l+1)*s*s;
			tag[x]=Tag(s,t,op);
		}
	}
	void pushdown(giant x,giant l,giant mid,giant r) {
		if (tag[x].op==0) return;
		if (tag[x].op==2) {
			doit(x<<1,l,mid,tag[x].s,tag[x].t,tag[x].op);
			doit(x<<1|1,mid+1,r,tag[x].s,tag[x].t,tag[x].op);
		} else if (tag[x].op==1) {
			doit(x<<1,l,mid,tag[x].s,tag[x].t,tag[x].op);
			doit(x<<1|1,mid+1,r,tag[x].s,tag[x].t,tag[x].op);
		}
		tag[x].clear();
	}
	void modify(giant x,giant L,giant R,giant l,giant r,lb s,lb t,int op) {
		giant mid=L+R>>1;
		pushdown(x,L,mid,R);
		if (L==l && R==r) {
			doit(x,L,R,s,t,op);
			return;
		}
		if (r<=mid) modify(x<<1,L,mid,l,r,s,t,op); else
		if (l>mid) modify(x<<1|1,mid+1,R,l,r,s,t,op); else {
			modify(x<<1,L,mid,l,mid,s,t,op);
			modify(x<<1|1,mid+1,R,mid+1,r,s,t,op);
		}
		dat[x]=dat[x<<1]+dat[x<<1|1];
	}
	void modify(giant l,giant r,lb s,lb t,int op) {
		modify(1,1,n,l,r,s,t,op);
	}
	Data query(giant x,giant L,giant R,giant l,giant r) {
		if (L==l && R==r) return dat[x];
		giant mid=L+R>>1;
		pushdown(x,L,mid,R);
		if (r<=mid) return query(x<<1,L,mid,l,r);
		if (l>mid) return query(x<<1|1,mid+1,R,l,r);
		Data r1=query(x<<1,L,mid,l,mid);
		Data r2=query(x<<1|1,mid+1,R,mid+1,r);
		Data ret=r1+r2;
		return ret;
	}
	Data query(giant l,giant r) {
		return query(1,1,n,l,r);
	}
} sgt;
lb calc(int thel,int ther) {
	giant len=ther-thel+1;
	Data d=sgt.query(thel,ther);
	lb up=d.xy,xp=(lb)d.x/len,yp=(lb)d.y/len;
	up-=xp*d.y+yp*d.x;
	up+=len*xp*yp;
	lb down=d.fang;
	down-=2*xp*d.x;
	down+=len*xp*xp;
	lb ret=up/down;
	return ret;
}
void radd(int thel,int ther,lb s,lb t) {
	sgt.modify(thel,ther,s,t,1);
}
void rmodi(int thel,int ther,lb s,lb t) {
	sgt.modify(thel,ther,s,t,2);
}
int main() {
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("my.out","w",stdout);
#endif
	n=read();
	for (int i=1;i<=n;++i) pf[i]=pf[i-1]+(giant)i*i;
	int m=read();
	for (int i=1;i<=n;++i) scanf("%Lf",basex+i);
	for (int i=1;i<=n;++i) scanf("%Lf",basey+i);
	sgt.build(1,1,n);
	while (m--) {
		int op=read();
		if (op==1) {
			int l=read(),r=read();
			lb ans=calc(l,r);
			printf("%.10Lf\n",ans);   // change back to .10lf
		} else if (op==2) {
			int l=read(),r=read();
			lb s,t;
			scanf("%Lf%Lf",&s,&t);
			radd(l,r,s,t);
		} else if (op==3) {
			int l=read(),r=read();
			lb s,t;
			scanf("%Lf%Lf",&s,&t);
			rmodi(l,r,s,t);
		}
	}
	return 0;
}