2021.7.15考试总结[NOIP模拟16]

ZJ模拟D2就是NB。。

T1 Star Way To Heaven

谁能想到这竟是个最小生成树呢？（T1挂分100的高人JYF就在我身边

把上边界和下边界看成一个点和星星跑最小生成树，从上边界开始跑到下边界，一定会出现一条将矩阵纵向一分为二的折线，其中线段都是最小距离，答案就是其中最长的线段的一半。

我直呼NB

由于这是个完全图，kruscal比prim多个log，会炸。

code：

#include<bits/stdc++.h>
#define debug exit(0)
using namespace std;
const double eps=1e-8;
const int NN=6e3+5;
int n,m,k,nod;
double ans,dis[NN],x[NN],y[NN];
bool vis[NN];
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
double ds(int a,int b){
    return sqrt(1.0*(x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]));
}
int main(){
    n=read(); m=read(); k=read();
    for(int i=1;i<=k;i++)
        x[i]=read(), y[i]=read();
    for(int i=1;i<=k;i++)
        dis[i]=m-y[i];
    dis[k+1]=m; dis[0]=1e9;
    while(1){
        int to=0;
        for(int i=1;i<=k+1;i++)
            if(!vis[i]&&dis[i]<dis[to]) to=i;
        ans=max(ans,dis[to]); vis[to]=1;
        if(to==k+1){
            printf("%.8lf\n",ans/2);
            return 0;
        }
        for(int i=1;i<=k;i++) 
            dis[i]=min(dis[i],ds(i,to));
        dis[k+1]=min(dis[k+1],1.0*y[to]);
    }
}

---

T2 God Knows

用B哥的话说，第一眼DP，第二眼不会。

看这题满脑子状压，但数据范围无情地把我拉回现实。

又想了一会树规，但假了。无奈之下，还是不想打状压，一调一小时于是果断糊了个DFS拿了20。

正解是个NB东西。把p看作带权序列，问题转化成求最小权极长上升子序列。

n2算法参考天皇skyh 博客（其实整道题都是参考天皇的

n2无法过掉，考虑神仙优化。如何优化呢？

万能的线段树！

发现能更新dp_i的j满足它的p是从j到i中所有小于p_i的最大值，但仍难以维护。

于是可以在线段树中维护以p为下标，i为关键值的一个单调栈。那么又到了我不懂的东西。

在每个节点上维护一个单调栈，记录栈底元素（i最大值），其中最小的权值（即为dp数组），和左儿子被右儿子最大值更新后的最小权值。

写一个cal函数计算当前节点的栈中加入关键值为val的元素后的最小权值。

用一个nxt计接下来要向栈中压进的元素，因为要把右儿子栈底压进左边，每次查询先询问右边来得到接下来询问范围。

code：

#include<bits/stdc++.h>
#define ld rt<<1
#define rd (rt<<1)|1
#define debug exit(0)
using namespace std;
const int NN=2e5+5,inf=2e9;
int n,p[NN],c[NN],nxt;
inline int Min(int a,int b){ return a<b?a:b; }
inline int Max(int a,int b){ return a<b?b:a; }
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
void write(int x){
    if(x<0) putchar('-'), x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
struct segment_tree{
    int l[NN<<2],r[NN<<2],mn[NN<<2],um[NN<<2],mx[NN<<2];
    int cal(int rt,int val){
        if(l[rt]==r[rt]) return mx[rt]>val?mn[rt]:inf;
        if(mx[rd]>val) return Min(um[ld],cal(rd,val));
        return cal(ld,val);
    }
    void pushup(int rt){
        mx[rt]=Max(mx[ld],mx[rd]);
        mn[rt]=Min(mn[rd],um[ld]=cal(ld,mx[rd]));
    }
    void build(int rt,int opl,int opr){
        l[rt]=opl; r[rt]=opr;
        mn[rt]=um[rt]=inf; mx[rt]=-1;
        if(opl==opr) return;
        int mid=opl+opr>>1;
        build(ld,opl,mid); build(rd,mid+1,opr);
    }
    int query(int rt,int opl,int opr){
        if(l[rt]>=opl&&r[rt]<=opr){
            int ans=cal(rt,nxt);
            nxt=Max(nxt,mx[rt]);
            return ans;
        }
        int mid=l[rt]+r[rt]>>1,ans=inf;
        if(opr>mid)  ans=Min(ans,query(rd,opl,opr));
        if(opl<=mid) ans=Min(ans,query(ld,opl,opr));
        return ans;
    }
    void insert(int rt,int pos,int i,int val){
        if(l[rt]==r[rt]){ mn[rt]=val; mx[rt]=i; return; }
        int mid=l[rt]+r[rt]>>1;
        if(pos<=mid) insert(ld,pos,i,val);
        else insert(rd,pos,i,val);
        pushup(rt);
    }
}s;
int main(){
    n=read();
    for(int i=1;i<=n;i++) p[i]=read();
    for(int i=1;i<=n;i++) c[i]=read();
    ++n; p[n]=n; s.build(1,0,n); s.insert(1,0,0,0);
    for(int i=1;i<=n;i++){
        nxt=-1;
        int tmp=s.query(1,0,p[i]-1)+c[i];
        s.insert(1,p[i],i,tmp);
        if(i==n) write(tmp), putchar('\n');
    }
    return 0;
}

---

T3 Lost My Music

一看就是个斜率，但我没学

用单调栈（可持久化）维护一个下凸包，每次求凸包切线。

暴力弹栈会炸，于是学着用了个倍增。代码挺短

贴个斜率优化博客

code：

#include<bits/stdc++.h>
#define debug exit(0)
using namespace std;
const double eps=1e-8;
const int NN=5e5+5;
int n,fa[NN][21],to[NN],nex[NN],head[NN],num,dep[NN],ans[NN],c[NN];
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
inline void add(int a,int b){
    to[++num]=b; nex[num]=head[a]; head[a]=num;
}
inline double Min(double a,double b){
    return a<b?a:b;
}
inline double calc(int x,int y){
    return 1.0*(c[y]-c[x])/(dep[x]-dep[y]);
}
void dfs(int st){
    int father=fa[st][0];
    for(int i=19;i>=0;i--){
        if(fa[father][i]<2) continue;
        if(calc(st,fa[father][i])>=calc(st,fa[fa[father][i]][0])) father=fa[father][i];
    }
    if(calc(st,father)>=calc(st,fa[father][0])&&father>1) father=fa[father][0];
    ans[st]=fa[st][0]=father;
    for(int i=1;i<=19;i++)
        fa[st][i]=fa[fa[st][i-1]][i-1];
    for(int i=head[st];i;i=nex[i]){
        dep[to[i]]=dep[st]+1;
        dfs(to[i]);
    }
}
int main(){
    n=read();
    for(int i=1;i<=n;i++) c[i]=read();
    for(int i=2;i<=n;i++){
        fa[i][0]=read();
        ans[i]=1e9+1e7;
        add(fa[i][0],i);
    }
    dfs(1);
    for(int i=2;i<=n;i++)
        printf("%.10lf\n",calc(i,ans[i]));
    return 0;
}