[考试反思]0917csp-s模拟测试45：天命

又倒一了。

关于心态，有不少想说的。

首先旁边坐了一个kx。他上来入手T1没多久就切了然后开始对拍拍了几十万组AC。

然而我觉得T1是神仙题。先进T2。

挺简单的，5分钟出正解，然后在打出来的时候突然有了个主意，感觉是等价的，就按照后来的那种想法打了。

然而根本就没有想，其实后者是错的，错的极其可笑，随随便便就能hack。

然而我没有证明也没有hack，就把正解埋没了。

大样例一过就交了，果断爆零。

这是后skyh开始犯贱，开始瞅着别人笑，我和mikufun鄙视了他一下后继续答题。

然后进T3。显然是个数据结构题。

思路还比较好想，花了15分钟想就想出来了。

但是瞬间就发现这题用的知识点有点多：链修改，求两点间最大边权，最小生成树。

也就是lct/树链剖分+克鲁斯卡尔。。。我脑子抽了还倍增了一下lca以及求距离

剩的时间比较多，我有一个致命的想法：

我平时考场上基本没A掉数据结构题过，这样下去不利于发展。

于是我毅然觉然地走上了正解的道路。

二营长虚了把空调关了，然后我本来就离空调远，特别热。。。

然后越打越头晕，感觉体温都上来了，而且看屏幕都逐渐有了重影（其实是屏幕的问题）

换了个稍硬的键盘敲不动，打各种板子的过程极其痛苦。。。

不管怎么说，2个小时，打出来了，过掉了大样例，心情极佳。

我感觉这是我为数不多能在考场上干掉的大型数据结构题。

然后数据出锅了，只有10分。

也感谢数据没有特别狗屎还给我留下了10分，不然我这场考试就爆零了。

考场上的我并不知道，我以为我A掉2个了。我感觉我状态不错，虽然头晕眼花满头大汗。

还有一个小时给T1，我一想kx在我旁边几十分钟就切了T1，我感觉我应该也可以。

然而感觉自己状态已经抗不住了，先出去透了个风，散散热，缓了一下脑子。

但是还是不会，一如既往的想用网络流乱搞二分图匹配。

按照数据范围说应该是60分？那么260应该不会太低。

所以不再冒着风险想正解了，开始调网络流。

死循环，调了一阵，过了大样例。交了，70分。

感觉数组开大了怕MLE，于是开小一点，再试了一遍大样例，再交。

这一次忘了删freopen了，用0分把70分盖掉了。

结束了，总分10分。

心态还是不行：期望太高了。考场上千万不能盲目自信。

然后还有在最后几分钟着急容易致错。这已经是第二次freopen出锅了。

另外题目的难易度判断也有问题。先T3后T1是个巨大的失误。。。

不要相信大样例！！！一定要对拍！！！

不要想太多。得分高就是王道。

就这样吧。

T1：kill

据说可以nlog做，不会。

两种n²都很好想。但都需要先发现一个性质。

一个性质是打的怪是连续的区间，枚举第一个打的即可。

另一个性质是按位置排序后，每个人打的每个怪的位置是递增的。

两个性质都很好证，但是考场上发现也是不容易。

然后就可以dp乱搞了。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int abs(int p){return p>0?p:-p;}
int dp[5005][5005],n,m,s,p[5005],q[5005];
int main(){
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=n;++i)scanf("%d",&p[i]);
    for(int i=1;i<=m;++i)scanf("%d",&q[i]);
    sort(p+1,p+1+n);sort(q+1,q+1+m);memset(dp,0x3f,sizeof dp);
    for(int i=0;i<=m;++i)dp[i][0]=0;
    for(int i=1;i<=m;++i)for(int j=1;j<=n;++j)
        dp[i][j]=min(dp[i-1][j],max(dp[i-1][j-1],abs(p[j]-q[i])+abs(s-q[i])));
    printf("%d
",dp[m][n]);
}

#include<cstdio>
#include<iostream>
using namespace std;
int fir[10005],l[25000005],to[25000005],cnt,n,m,p[5005],q[5005],s,dep[10005];
bool v[25000005];int qu[10005];
int abs(int p){return p>0?p:-p;}
void link(int a,int b,int vv){
    l[++cnt]=fir[a];fir[a]=cnt;to[cnt]=b;v[cnt]=vv;
}
bool bfs(){
    int top=1;for(int i=1;i<=n+m+1;++i)dep[i]=-1;
    for(int qh=1;qh<=top;++qh)for(int i=fir[qu[qh]];i;i=l[i])if(v[i]&&dep[to[i]]==-1)
        dep[to[i]]=dep[qu[qh]]+1,qu[++top]=to[i];
    return dep[n+m+1]!=-1;
}
int dfs(int p,int flow){//printf("%d %d
",p,flow);
    if(p==n+m+1)return flow;
    int res=flow;
    for(int i=fir[p];i;i=l[i])if(dep[to[i]]==dep[p]+1&&v[i]&&res){
        int acs=dfs(to[i],1);
        if(!acs){dep[to[i]]=0;continue;}
        v[i]=0;v[i^1]=1;res--;
    }
    return flow-res;
}
bool chk(int tim){
    int maxflow=0;
    for(int i=0;i<=n+m+1;++i)fir[i]=0;cnt=1;
    for(int i=1;i<=n;++i)link(0,i,1),link(i,0,0);
    for(int i=1;i<=m;++i)link(n+i,n+m+1,1),link(n+m+1,n+1,0);
    for(int i=1;i<=n;++i)for(int j=1;j<=m;++j)if(abs(p[i]-q[j])+abs(q[j]-s)<=tim)
        link(i,n+j,1),link(n+j,i,0);
    while(bfs())maxflow+=dfs(0,n);//,printf("%d
",maxflow);
    return maxflow==n;
}
int main(){freopen("kill.in","r",stdin);
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=n;++i)scanf("%d",&p[i]);
    for(int j=1;j<=m;++j)scanf("%d",&q[j]);
    int l=0,r=2000000000;
    while(l<r-1)if(chk(l+r>>1))r=l+r>>1;else l=(l+r>>1)+1;
    if(chk(l))printf("%d
",l);else printf("%d
",r);
}

思路积累：

• 猜测性质，发现性质，证明性质。
• 网络流乱搞二分图匹配。
• 网络流求最大权值时不能直接求，采用二分答案。

T2：beauty

贪心。

从下往上回溯时，你当然不想让子树里的点配对，让它们往上一起延伸显然会使答案更优。

但是如果子树外能配对的点的数量已经没有子树里面的多了，那么就必须在这里配对几个了。

不能理解为：如果子树里多余k就必须配对，错的。

两遍dfs。

#include<cstdio>
int n,k,a,fir[100005],l[200005],to[200005],cnt,siz[100005],r[100005];long long ans;
void link(int a,int b){l[++cnt]=fir[a];fir[a]=cnt;to[cnt]=b;}
void dfs(int p,int fa){
    r[p]=siz[p];
    for(int i=fir[p];i;i=l[i])if(to[i]!=fa)dfs(to[i],p),siz[p]+=siz[to[i]];
}
void DFS(int p,int fa){
    for(int i=fir[p];i;i=l[i])if(to[i]!=fa)DFS(to[i],p),r[p]+=r[to[i]],ans+=r[to[i]];
    if(p==1)return;
    while(r[p]>k*2-siz[p])r[p]-=2;
}
int main(){//freopen("beauty.in","r",stdin);
    scanf("%d%d%d",&n,&k,&a);
    for(int i=1,x;i<=k<<1;++i)scanf("%d",&x),siz[x]++;
    for(int i=1,x,y;i<n;++i)scanf("%d%d",&x,&y),link(x,y),link(y,x);
    dfs(1,0);DFS(1,0);printf("%lld
",ans);
}

思路积累：

• 树上贪心：考虑链的延伸。
• 不要投机取巧，认真写式子，仔细证明。

T3：weight

数据出锅，不保证联通，所有与1号点不联通的边的答案都是0。

因为std是从1号节点开始dfs的，所以不联通的点没更新，答案都是0。

观察题目，既然题目一直在说最小生成树，那就把最小生成树弄出来吧。

发现：已经在树上的边，答案一定不比目前权值小超过1，对于非树上的边答案一定不比当前权值小。

对于非树边，只要它的权值小于最小生成树上对应两点之间的边权最大值，那么它就可以取代那条边进入最小生成树。

对于树边，它不能被取代，所以它要小于所有经过这条边的非树边的最小值。

链修改，树上两点距离，单点查询。

lct板子。或者树链剖分。或者倍增离线处理（推荐zkt的，很好打）。cbx说可以线段树合并。

思路不难，关键在实现。

因为数据有锅，所以不能用“p的父亲的重儿子是否为p”的方法判p是否为重链顶端。会炸成10分。

//对于不再最小生成树上的边，答案为两点之间边的最大值-1
//更新答案时，它只会覆盖一条链上的所有边，这条链上的所有边的答案对其权值-1取min
//链操作--树链剖分？lct？
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,a,fir[70005],l[200005],to[200005],siz[70005],cnt,hson[70005],tfe[70005];
int ans[200005],top[70005],dep[70005],f[70005][20],mx[70005][20],v[200005];
int len[70005],tcnt,lc[1000005],rc[1000005],w[1000005],rt[70005],lz[1000005];
int cl[1000005],cr[1000005],tmp[70005],g[200005];
void build(int &p,int l,int r){
    p=++tcnt;w[p]=1234567890;
    cl[p]=l;cr[p]=r;
    if(l==r)return;
    build(lc[p],l,l+r>>1);
    build(rc[p],(l+r>>1)+1,r);
}
void down(int p){//printf("%d %d %d %d %d
",p,lc[p],rc[p],w[lc[p]],w[rc[p]]);
    w[lc[p]]=min(w[lc[p]],lz[p]);
    w[rc[p]]=min(w[rc[p]],lz[p]);
    if(lz[lc[p]])lz[lc[p]]=min(lz[lc[p]],lz[p]);else lz[lc[p]]=lz[p];
    if(lz[rc[p]])lz[rc[p]]=min(lz[rc[p]],lz[p]);else lz[rc[p]]=lz[p];
    lz[p]=0;//printf("%d %d %d %d %d
",p,lc[p],rc[p],w[lc[p]],w[rc[p]]);
}
void set(int p,int l,int r,int W){//printf("%d %d %d %d %d %d
",p,l,r,w,cl[p],cr[p]);
    if(l<=cl[p]&&cr[p]<=r){if(lz[p])lz[p]=min(lz[p],W);else lz[p]=W;w[p]=min(w[p],W);return;}
    if(l<=cr[lc[p]])set(lc[p],l,r,W);
    if(r>=cl[rc[p]])set(rc[p],l,r,W);
}
void ask(int p){//printf("%d
",p);
    if(cl[p]==cr[p]){tmp[cl[p]]=w[p];return;}
    if(lz[p])down(p);
    ask(lc[p]);ask(rc[p]);
}
struct edge{
    int a,b,v,num;
    friend bool operator<(edge a,edge b){return a.v<b.v;}
}e[100005];
void link(int a,int b,int vv,int gg){l[++cnt]=fir[a];fir[a]=cnt;to[cnt]=b;v[cnt]=vv;g[cnt]=gg;}
int fa[70005],in[100005];
int find(int k){return fa[k]==k?k:fa[k]=find(fa[k]);}
void Kruscal(){
    sort(e+1,e+1+m);
    for(int i=1;i<=n;++i)fa[i]=i;
    for(int i=1;i<=m;++i)if(find(e[i].a)!=find(e[i].b))
        fa[fa[e[i].a]]=fa[e[i].b],in[e[i].num]=1,
        link(e[i].a,e[i].b,e[i].v,e[i].num),link(e[i].b,e[i].a,e[i].v,e[i].num);
}
void dfs(int p,int fa){
    siz[p]=1;dep[p]=dep[fa]+1;f[p][0]=fa;
    for(int i=1;i<=18;++i)f[p][i]=f[f[p][i-1]][i-1],mx[p][i]=max(mx[p][i-1],mx[f[p][i-1]][i-1]);
    for(int i=fir[p];i;i=l[i])if(to[i]!=fa){
        mx[to[i]][0]=v[i];
        dfs(to[i],p),siz[p]+=siz[to[i]],tfe[to[i]]=g[i];
        if(siz[to[i]]>siz[hson[p]])hson[p]=to[i];
    }
}
void DFS(int p,int tp){
    top[p]=tp;len[tp]=dep[p]-dep[tp]+1;
    for(int i=fir[p];i;i=l[i])if(to[i]!=f[p][0]&&to[i]!=hson[p])DFS(to[i],to[i]);
    if(hson[p])DFS(hson[p],tp);
}
int lca(int a,int b){
    if(dep[a]<dep[b])swap(a,b);
    int subdep=dep[a]-dep[b];
    for(int i=18;~i;--i)if(subdep&1<<i)a=f[a][i];
    if(a==b)return a;
    for(int i=18;~i;--i)if(f[a][i]!=f[b][i])a=f[a][i],b=f[b][i];
    return f[a][0];
}
int cal(int p,int fa){
    int re=0,subdep=dep[p]-dep[fa];
    for(int i=18;~i;--i)if(subdep&1<<i)re=max(re,mx[p][i]),p=f[p][i];
    return re;
}
void update(int p,int fa,int w){
    while(top[p]!=top[fa]){
        set(rt[top[p]],1,dep[p]-dep[top[p]]+1,w);
        p=f[top[p]][0];
    }
    if(p!=fa)set(rt[top[p]],dep[fa]-dep[top[p]]+2,dep[p]-dep[top[p]]+1,w);
}
void dfs_hson(int p,int ord){
    ans[tfe[p]]=tmp[ord]-1;
    if(hson[p])dfs_hson(hson[p],ord+1);
}
int main(){//freopen("weight.in","r",stdin);
    scanf("%d%d%d",&n,&m,&a);
    for(int i=1;i<=m;++i)scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].v),e[i].num=i;
    Kruscal();dfs(1,0);DFS(1,1);
    for(int i=1;i<=n;++i)if(len[i])build(rt[i],1,len[i]);
    for(int i=1;i<=m;++i)if(!in[e[i].num]){
        int LCA=lca(e[i].a,e[i].b),DT=max(cal(e[i].a,LCA),cal(e[i].b,LCA));
        ans[e[i].num]=DT-1;
        update(e[i].a,LCA,e[i].v);update(e[i].b,LCA,e[i].v);
    }
    for(int i=1;i<=n;++i)if(hson[f[i][0]]!=i)ask(rt[i]),dfs_hson(i,1);//for(int i=1;i<=4;++i)printf("%d
",tmp[i]);
    for(int i=1;i<=m;++i)if(ans[i]==1234567889)printf("-1 ");else printf("%d ",ans[i]);
}

思路积累：

• 链修改的各种方法：lct，熟练剖分。
• 离线。
• 最小生成树的性质。
• 判熟练剖分重儿子的方法。