tg 74 solution

tg 74 solution

T1

暴搜题

这个sb在赛时打了个垃圾暴搜

事实上你打个表就可能会发现结论

下面给出一个构造方案并给出严谨证明

就是首先两个数组分别填上\(1\)和\(2\)

然后每次考虑从\(i-1\to i\)

新增的部分考虑将对方复制然后加上\(2^i\)接在自己的后面

给出证明：

设当前答案数组\(a,b\)

显然\(n=1\)的时候，我们的初始答案是合法的

即\(\forall p\in [0,n),\sum\limits^{p}_{i=1} a_i^p=\sum\limits^{p}_{i=1} b_i^p\)

假设\(n=t,t\in N_{+}\)的时候,记\(size=2^t\)，

\(\forall p\in [0,t),\sum\limits^{p}_{i=1} a_i^p=\sum\limits^{p}_{i=1} b_i^p\)

此时\(:n\to t+1,\)

\(\forall i\in [size+1,2\cdot size),a_i\leftarrow b_{i-size}+2^t,b_i\leftarrow b_{i-size}+2^t\)

\(\sum \limits ^{2\cdot size}_{i=size+1} a_i^p=\sum \limits ^{size}_{i=1} (b_i+2^t)^p\)

\(\sum \limits ^{2\cdot size}_{i=size+1} a_i^p=\sum \limits ^{size}_{i=1} \sum \limits^{p}_{j=1} C^{j}_{p}b_i^j\)

此时我们提出组合数

\(\sum \limits ^{2\cdot size}_{i=size+1} a_i^p=\sum \limits^{p}_{j=1} C^{j}_{p} \sum \limits ^{size}_{i=1} b_i^j\)

同理，把\(\sum \limits ^{2\cdot size}_{i=size+1} b_i^p\)换掉，有

\(\sum \limits ^{2\cdot size}_{i=size+1} b_i^p=\sum \limits^{p}_{j=1} C^{j}_{p} \sum \limits ^{size}_{i=1} a_i^j\)

不巧的是\(,\forall p\in [0,t),\sum\limits^{p}_{i=1} a_i^p=\sum\limits^{p}_{i=1} b_i^p\)

于是\(p=[0,t)\)的部分就结束了

然后就是如果\(p=t\)的话两边式子做个差，

你会发现两个最高次项消没了，于是剩下的又是系数相等，

于是就证完了

---

T2

"zazheng"

"zuotianhackwo" "jintiannihailai"

首先记\(S_{i}=\{V'，E'\},V'=[1,i],\forall (u,v)\in E',u\in V',v\in V'\)

显然的\(,\forall i,S_i \in G\)对吧

事实上，我们只需要知道\(S_{i}\)和\(S_{i-1}\)

就可以知道\(i\)和\([1,i-1)\)中的点连了多少条边

事实上，记\(f(x)\)表示\([1,x]\)中所有点向\(x\)连的边数

显然的，\(f(x)\)随着\(x\)的增大单调不降，

因为差分的意义就是\(x\to i\)有没有连边，也不可能出负数......

单调了二分出所有改变点就不难了

对于一次二分的过程是：

一开始\(l\)是上一个拐点，\(r\)就是固定右端点

记\(mid=\frac{l+r}{2}\)

当\(f(mid)=f(l)\)时，\(l\leftarrow mid+1\)

否则\(r\leftarrow mid\)

一直二分到\(l=r，\)此时\(l\)就是一个和\(x\)连边的点

显然，\(f_{mid}\)可以通过询问\(V_{mid}\or {x}\)减去\(|E_{mid}|\)得到,而\(|E_{mid}|\)可以预处理每次一个询问得到

对于每个点\(i\)持续进行上述二分即可确定所有边

每条边一次二分，算上预处理，询问次数\(n+m\log n\)

T3

线段树，

势能分析表明时间复杂度是对的

直接放码了

点击查看代码

#include <bits/stdc++.h>
using namespace std;
#define D double 
const int o=2222222,u=43;
const D cosin=0.73908513321516064166;
ifstream fin("excalibur.in");
ofstream fout("excalibur.out");
int n,m,L,R;
D a[o],P[u];
struct SgT{
    D val[o][u];
    int num[o],lazy[o],cov[o];
    void up(int p){
        num[p]=0;
        int ls=p*2,rs=p*2+1;
        for(int i=0,l=num[ls],r=num[rs];i<u;i++){
            val[p][i]=val[ls][l]+val[rs][r];
            l++,r++;
            l=(l==u?0:l);
            r=(r==u?0:r);
        }
    }
    void build(int p,int l,int r){
        if(l==r){
            val[p][0]=a[l];
            for(int i=1;i<u;i++)
                val[p][i]=cos(val[p][i-1]);
            return;
        }
        int mid=(l+r)/2;
        build(p*2,l,mid);
        build(p*2+1,mid+1,r);
        up(p);
    }
    void down(int p,int l,int r){
        int ls=p*2,rs=p*2+1;
        int mid=(l+r)/2;
        if(cov[p]){
            cov[ls]=cov[rs]=cov[p];
            num[ls]=num[rs]=num[p];
            lazy[ls]=lazy[rs]=0;
            D k=(mid-l+1.0)/(r-l+1.0);
            for(int i=0;i<u;i++)
                val[ls][i]=val[p][i]*k;
            k=1-k;
            for(int i=0;i<u;i++)
                val[rs][i]=val[p][i]*k;
            cov[p]=lazy[p]=0;
        }
        if(lazy[p]>0){
            int t=max(0,min(lazy[p],u-lazy[ls]));
            D v=cosin*(mid-l+1);lazy[ls]+=t;
            for(int i=1,&x=num[ls];i<=lazy[p];i++){
                val[ls][x]=v;x++;
                x=(x==u?0:x);
            }
            t=max(0,min(lazy[p],u-lazy[rs]));
            v=cosin*(r-mid);lazy[rs]+=t;
            for(int i=1,&x=num[rs];i<=lazy[p];i++){
                val[rs][x]=v;x++;
                x=(x==u?0:x);
            }
            lazy[p]=0;
        }
    }
    void cover(int p,int l,int r){
        if(L<=l&&r<=R){
            cov[p]=1;
            lazy[p]=num[p]=0;
            for(int i=0;i<u;i++)
                val[p][i]=P[i]*(r-l+1);
            return;
        }
        down(p,l,r);int mid=(l+r)/2;
        if(L<=mid)cover(p*2,l,mid);
        if(R>mid)cover(p*2+1,mid+1,r);
        up(p);
    }
    void change(int p,int l,int r){
        if(val[p][num[p]]==cosin*(r-l+1))return;
        if(L<=l&&r<=R){
            lazy[p]++;
            val[p][num[p]]=cosin*(r-l+1);
            num[p]++;
            num[p]=(num[p]==u?0:num[p]);
            return ;
        }
        down(p,l,r);int mid=(l+r)/2;
        if(L<=mid)change(p*2,l,mid);
        if(R>mid)change(p*2+1,mid+1,r);
        up(p);
    }
    D ques(int p,int l,int r){
        if(val[p][num[p]]==cosin*(r-l+1))
            return cosin*(min(r,R)-max(l,L)+1);
        if(L<=l&&r<=R)
            return val[p][num[p]];
        down(p,l,r);
        int mid=(l+r)/2;D ans=0;
        if(L<=mid)ans+=ques(p*2,l,mid);
        if(R>mid)ans+=ques(p*2+1,mid+1,r);
        return ans;
    }
}T;
void in(){
    fin>>n>>m;
    for(int i=1;i<=n;i++)fin>>a[i];
}
void work(){
    T.build(1,1,n);
    for(int i=1;i<=m;i++){
        int op;
        fin>>op>>L>>R;
        if(op==1)T.change(1,1,n);
        if(op==2)fout<<fixed<<setprecision(8)<<T.ques(1,1,n)<<"\n";
        if(op==3){
            fin>>P[0];
            for(int j=1;j<u;j++)P[j]=cos(P[j-1]);
            T.cover(1,1,n);
        }
    }
}
int main(){
    ios::sync_with_stdio(0);
    fin.tie(0),fout.tie(0);
    in();work();
    return 0;
}

T4