WC2018伪题解

NOIP分数过低的场外选手，一个月之后才有幸膜到这套卷子。感觉题目质量很不错啊，可惜了T1乱搞可过，T2题目出锅非集训队员没有通知到，导致风评大幅被害。

感觉Cu的话随手写两个暴力就稳了，Ag的话T3稍微搞出点性质就稳了，Au的话T1乱搞和T3中搞出一个就比较稳了。

可以发现T1的28分和T3的16分只要读懂题目（会用交互）就能拿到。下面看下这两题的各部分分解法。

T1

Subtask 1(28 pts):直接暴力，倍增LCA即可。$O(n^2 \log n)$

Subtask 2(16 pts):特殊性质0，实际上就是一棵树，直接跑树的直径即可。 $O(n)$

Subtask 3(12 pts):特殊性质12，一棵树加一条链。枚举LCA，问题变成求$d_a+d_b-2*d_{lca}+v_b-v_a$其中v是链上前缀和。

后面还有很多档部分分，但都较复杂，正解则使用了边分治。但是有一种有理有据的乱搞方法可以通过所有官方数据。

重复多次以下操作：

• 从一个点a出发，找另一个点b使得答案最大
• 从b出发，找到一个点c使得答案最大，如此反复

先将序列random_shuffle()一下，然后用爬山法，取20次左右的初始值，每次按上面的方法更新，发现答案不更优则停止。

 #include<cstdio>
 #include<algorithm>
 #define rg register int
 #define rep(i,l,r) for (rg i=l; i<=r; i++)
 typedef long long ll;
 using namespace std;

 const int N=;
 int pos[N],vis[N],q[N],u,v,n;
 ll dis[][N],ans,w;

 struct Graph{
     struct edge{ int nt,to; ll dis; }g[N<<];
     int head[N],num;
     void insert(rg from,rg to,ll dis){ g[++num]=(edge){head[from],to,dis},head[from]=num; return; }
 }G[];

 void bfs(rg op,rg S){
     rep(i,,n) vis[i]=;
     rg h=,t=; q[t]=S,vis[S]=,dis[op][S]=;
     while (h<t){
         rg x=q[++h],v;
         for (rg i=G[op].head[x];i;i=G[op].g[i].nt){
             v=G[op].g[i].to; if (vis[v]) continue;
             vis[v]=,q[++t]=v,dis[op][v]=dis[op][x]+G[op].g[i].dis;
         }
     }
     return;
 }

 int main(){
     freopen("tunnel.in","r",stdin);
     freopen("tunnel.out","w",stdout);
     srand(); scanf("%d",&n);
     rep(j,,)
         for (rg i=,u,v;i<n;++i){
             ll w; scanf("%d%d%lld",&u,&v,&w);
             G[j].insert(u,v,w); G[j].insert(v,u,w);
         }
     rep(i,,n) pos[i]=i;
     random_shuffle(pos+,pos+n+);
     for (int T=,rt; T<=; ++T){
         rt=pos[T]; ll ret=;
         while (){
             bfs(,rt); bfs(,rt); bfs(,rt);
             ll res=; rg id=;
             rep(i,,n)
                 if (res<dis[][i]+dis[][i]+dis[][i])
                     res=dis[][i]+dis[][i]+dis[][i],id=i;
             if (ret<res) ret=res,rt=id; else break;
         }
         ans=max(ans,ret);
     }
     printf("%lld\n",ans);
     return ;
 }

T3

Subtask 1:(20 pts) $O(n^2)$以上的限制跟没有限制没什么区别，直接$O(n^2)$跑暴力即可。

Subtask 2:(15 pts) 由于是完全二叉树，我们每次随机选一个未知的点，然后径直走过去即可。探寻路径的次数近似于每个点的深度，当然不超过log n，所以可以$O(n \log n)$过。

Subtask 3:(30 pts) 一条链，每次找一个未知点径直走过去。可以证明期望次数是ln n级别的。

设E(n)表示当只有左端点未知时，需要尝试的次数。则有

$$E(n)=1+\frac{1}{n}\sum_{i=0}^{n-1} E(i)$$ $$nE(n)+1+E(n)=(n+1)E(n+1)$$ $$ E(n+1)-E(n)=\frac{1}{n+1}$$ $$E(n)=\sum_{i=1}^{n} \frac{1}{i}\approx \ln n +0.5$$

如果每次从1扩展可能不能过最后一个点，错误次数是2 ln n + 1的，用左右端点尝试的话可以做到ln n +0.5，只有$\frac{144}{100000}$的概率无法通过。

满分做法就非常有趣了。既然已经确定是随机化了，每次随机的点又不能控制，我们只能用最小的代价找到离这个点最近的已知点扩展过去。

可以发现每次扩展都新形成一条链，这就变成了动态树链剖分问题，可以用LCT($O(n \log n)$)或动态点分治($O(n \log^2 n)$)解决。

这样直接把LCT模板拖过来就好了，LCT查询的是左子树和右子树中离这个点最近的点分别是哪个，记得每次新加入链的时候要access()以保证复杂度。

 #include "rts.h"
 #include <cstdio>
 #include <algorithm>
 #define ls ch[x][0]
 #define rs ch[x][1]
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 using namespace std;
 typedef long long ll;
 typedef pair<int,int> pii;

 const int N=;
 int n,b[N],t,ch[N][],f[N],l[N],r[N];

 int sj(int l,int r){ return rand()%(r-l+)+l; }

 int isroot(int x) { return (!f[x])||(ch[f[x]][]!=x && ch[f[x]][]!=x);}
 void upd(int x){ l[x]=r[x]=x; if (ls) l[x]=l[ls]; if (rs) r[x]=r[rs]; }

 void rot(int x){
     int y=f[x],z=f[y],w=ch[y][]==x;
     ch[y][w]=ch[x][w^]; f[ch[x][w^]]=y;
     if (!isroot(y)) ch[z][ch[z][]==y]=x;
     f[x]=z; f[y]=x; ch[x][w^]=y; upd(y);
 }

 void splay(int x){
     while (!isroot(x)){
         int y=f[x];
         if (!isroot(y)) ((ch[f[y]][]==y)^(ch[y][]==x)) ? rot(x) :rot(y);
         rot(x);
     }
     upd(x);
 }

 void access(int x){ for (int y=; x; y=x,x=f[x]) splay(x),ch[x][]=y,upd(x); }

 void work(int x){
     int now=,v; splay(now);
     while (!b[x]){
         v=explore(now,x);
         if (v==r[ch[now][]]) now=ch[now][];
         else if (v==l[ch[now][]]) now=ch[now][];
             else if (b[v]) splay(v),now=v;
                 else b[v]=,f[v]=now,now=v;
     }
     access(x);
 }

 void work1(){ rep(i,,n) if (!b[i]) work(i); }

 void work2(){
     int l=,r=; int tot=; b[]=;
     while (tot<n){
         int k=sj(,n); while (b[k]) k=sj(,n);
         int p=explore(l,k);
         if (b[p])
             while (r!=k) r=explore(r,k),b[r]=,tot++;
         else{
             l=p; b[p]=; tot++;
             while (l!=k) l=explore(l,k),b[l]=,tot++;
         }
     }
 }

 void play(int _n,int _t,int type){ n=_n; t=_t; if(type==) work2(); else work1(); }

总结：一定要提高自己的乱搞技巧，加强码力，不要放过任何一个得分点。会写的就不要写错，学会猜结论。