P12504 「ROI 2025 Day1」树上的青蛙

树上最大匹配对数，考虑贪心。怎么感觉题解都没有很讲明白复杂度优化的过程，也可能是我太蠢了。

\(d\) 为偶数的情况 \(d\to d-1\) 没有影响，所以只讨论 \(d\) 为奇数。

假设 \(lca(u,v)=w\)，\(V_i=\{u|dep_u=i\}\)。

\(u\) 到 \(v\) 的路径一定形如 \(u\to p\to v\) 其中 \(p\) 为 \(lca(u,v)\) 到根上路径中的任意一点。从 \(p\) 的角度考虑，假设点对 \((u,v)\) 的路径均为 \(u\to p\to v\)，则尽量匹配满足条件且形如 \((u,v)\) 满足 \(dis(u,v)=d\) 的点对是不劣的。

对于 \((u,v),dis(u,v)<d\) 无论将其提至任意祖先 \(p\) 满足 \(dis(u,p)+dis(p,v)\le d\) 时均能匹配（\(dis(u,p)+dis(p,v)=dis(u,v)+2\cdot dis(w,p)\)，显然奇偶性不变）。

不考虑奇偶性，\((u,v)\) 在 \(p\) 处匹配需要满足的条件为 \(dis(u,v)+2\cdot dis(w,p)\le d\)。转化一下，对于点 \(u\) 在 \(p\) 处能匹配的 \(v\) 要满足

\(dis(u,v)\le d-2\cdot dis(w,p)\\\to dep_u+dep_v-2\cdot dep_w\le d-2\cdot (dep_w+dep_p-2\cdot dep_p)\\\to dep_v\le d+2\cdot dep_p-dep_u\)

所以 \(u\) 越往上提能匹配的点越多。

然后剩下未匹配的点在根，按点对间距离从大到小匹配即可。

应该想想就明白了。

有了贪心策略，就可以考虑暴力了。

对于 \(p\)，找出子树中所有未匹配的点，对于每个点，查询是否存在 \(dis(u,v)+2\cdot dis(w,p)=dep_u+dep_v-2\cdot dep_p=d\) 的点对，这个可以按深度奇偶分两个 set 简单维护，然后匹配删去即可。复杂度 \(O(n^2\log n)\)

发现可以先枚举 \(dep_u\)，显然可能匹配的 \(dep_u\le dep_p+d\)，然后用 vector 维护一下 \(V_i\) 即可。复杂度 \(O(nd+n^2\log n)\)。

子树中的剩余未匹配点集的信息显然可以先用 dsu on tree 优化。于是优化至 \(O(nd+n\log n)\)。

现在瓶颈就在匹配过程中的 \(O(nd)\)。

无非就是要找到 \((u,v)\) 满足 \(dep_u+dep_v-2\cdot dep_p\) 直接从 \((u,v)\) 考虑。对于 \((u,v)\) 找到满足条件的 \(dep_p=\frac{dep_u+dep_v}{2}\)，将 \((dep_u,dep_v)\) 挂在这个深度上，表示在此深度可以将 \(dep_u\) 与 \(dep_v\) 中的点匹配。可以拿优先队列维护，点 \(u\) 将所有 \(dep_p\ge dep_u\) 的深度对处理了。

贪心的考虑，点 \(u\) 尽量最大的 \(dep_v\) 是优的，根据上文对匹配的限制可得深度最大限制最严，于是每个点只需找到满足 \(dep_u+dep_v-2\cdot dep_w\le d\) 中最大的 \(dep_v\) 形成点对，类似支配对，于是当前点对数就降成 \(O(n)\)，而 dsu on tree 的复杂度因为套了个 set 变为 \(O(n\log^2n)\)，不过仍能接受。

问题是因为点对间没有保证点不重复，所以会出现深度对 \((dep_u,dep_v)\) 但 \(dep_v\) 中的点已经被其他点全部匹配的情况。那么 \(dep_u\) 就需要同上文再找到当前满足条件的最大的 \(dep_v\)，再挂在新的 \(dep_p\) 上（当前子树中无法匹配 \(dep_u\) 提到祖先子树，未匹配点集的信息更多，寻找匹配），将这种情况称作“上提”。

若 \(dep_u\) 匹配了一次 \(dep_v\)，而 \(V_{dep_u}\ne \varnothing\)，也需要将 \(dep_u\) 再插入一次，因为深度对是不重的。

void solve(int u){while(dl.size()){if(dl.top().fi<d[u]&&u!=1)return;int d1=dl.top().se,d2=D+2*dl.top().fi-d1;dl.pop();fl[d1].erase(d2);if(d1&1)swap(d1,d2);if(!w[1].count(d2)){auto nx=w[0].upper_bound(d1);if(nx!=w[0].begin())add((--nx)->fi,0,u,1);}if(!w[0].count(d1)){auto ny=w[1].upper_bound(d2);if(ny!=w[1].begin())add((--ny)->fi,0,u,1);}if(!w[0].count(d1)||!w[1].count(d2))continue;int x=w[0][d1].back(),y=w[1][d2].back();w[0][d1].pop_back(),w[1][d2].pop_back();ans.pb(mp(x,y)),vis[x]=vis[y]=1;if(!w[0][d1].size())w[0].erase(d1);if(!w[1][d2].size())w[1].erase(d2);auto nx=w[0].upper_bound(d1),ny=w[1].upper_bound(d2);if(w[0].count(d1)){auto nx=w[0].upper_bound(d1);if(nx!=w[0].begin())add((--nx)->fi,0,u,1);}if(w[1].count(d2)){auto ny=w[1].upper_bound(d2);if(ny!=w[1].begin())add((--ny)->fi,0,u,1);}}
}

然后可以写出这份代码，大部分情况下是优秀的，但是还是能被卡成 \(O(nd)\)，因为 \(dep_u\) 对应的深度对可能被上提 \(d\) 次。

64 pts。

考虑问题出在哪。\(dep_u\) 上提后对应的 \(dep_v\) 仍被匹配，继续上提。能否保证 \(dep_u\) 至多上提一次就能找到匹配。

发现深度对匹配的顺序为 \((u,v)\) 按对应的 \(dep_p\) 降序排序。

那么假设深度对 \((u,v)\) 匹配后，\(V_{v}=\varnothing\)，那么只需要找到最大的满足 \(\le u\) 的深度对应的深度 \(x\) 对上提即可。

因为对于所有 \((dep,v)\) 的深度对，上提后都是形如 \((dep,y)\) 的深度对，而根据上文对应 \(dep_p\) 的计算式子，显然 \((x,y)\) 对应的 \(dep_p\) 最大，其他的深度对均需要在其匹配之后才有可能匹配。

于是每个深度对匹配后只用上提至多一个深度对，而匹配的总次数 \(\le \lfloor\frac{n}{2}\rfloor\)，所以复杂度就优化到 \(O(n\log n+n\log^2 n)\)。

100 pts。

#include<bits/stdc++.h>
#define fin(x) freopen(#x".in","r",stdin)
#define fout(x) freopen(#x".out","w",stdout)
#define fr(x) fin(x),fout(x);
#define Fr(x,y) fin(x),fout(y)
#define INPUT(_1,_2,FILE,...) FILE
#define IO(...) INPUT(__VA_ARGS__,Fr,fr)(__VA_ARGS__)
using namespace std;
#define mp make_pair
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
#define cfast ios::sync_with_stdio(false);cin.tie(0),cout.tie(0)
#define ll long long
#define ull unsigned long long
#define intz(x,y) memset((x),(y),sizeof((x)))
char *p1,*p2,buf[100000];
#define nc() (p1==p2 && (p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
#define tup(x) array<int,(x)>
inline ll read(){ll x=0,f=1;char ch=nc();while(ch<48||ch>57){if(ch=='-')f=-1;ch=nc();}while(ch>=48&&ch<=57)x=x*10+ch-48,ch=nc();return x*f;
}
const int N=5e5+5;
vector<int>e[N];
unordered_map<int,bool>fl[N];
vector<pii>ans;bool vis[N];
int siz[N],d[N],son[N],dfn[N],idx[N],ct,n,D;
priority_queue<pii>dl;
map<int,vector<int> >w[2];
void dfs(int u,int fa){siz[u]=1,d[u]=d[fa]+1;for(int v:e[u])if(v^fa){dfs(v,u),siz[u]+=siz[v];if(siz[v]>siz[son[u]])son[u]=v;}
}
inline void add(int x,int u,int _u,bool flag){auto it=w[!(x&1)].upper_bound(D-x+2*d[_u]);if(it!=w[!(x&1)].begin()){--it;int dep=(x+(it->fi)-D)/2;if(!fl[x].count(it->fi))dl.push(mp(dep,x)),fl[x][it->fi]=1;}if(!flag)w[x&1][x].pb(u);
}
void solve(int u){while(dl.size()){if(dl.top().fi<d[u]&&u!=1)return;int d1=dl.top().se,d2=D+2*dl.top().fi-d1;dl.pop();fl[d1].erase(d2);if(d1&1)swap(d1,d2);if(!w[0].count(d1)||!w[1].count(d2))continue;int x=w[0][d1].back(),y=w[1][d2].back();w[0][d1].pop_back(),w[1][d2].pop_back();ans.pb(mp(x,y)),vis[x]=vis[y]=1;if(!w[0][d1].size())w[0].erase(d1);if(!w[1][d2].size())w[1].erase(d2);auto nx=w[0].upper_bound(d1),ny=w[1].upper_bound(d2);if(nx!=w[0].begin())add((--nx)->fi,0,u,1);if(ny!=w[1].begin())add((--ny)->fi,0,u,1);}
}
void dsu(int u,int fa){idx[dfn[u]=++ct]=u;for(int v:e[u])if((v^fa)&&(v^son[u])){dsu(v,u);for(int i=dfn[v],V=v;i<dfn[v]+siz[v];fl[d[V]].clear(),V=idx[++i]);while(!dl.empty())dl.pop();w[0].clear(),w[1].clear();}if(son[u])dsu(son[u],u);add(d[u],u,u,0);for(int v:e[u])if((v^fa)&&(v^son[u]))for(int i=dfn[v],V=v;i<dfn[v]+siz[v];V=idx[++i])if(!vis[V])add(d[V],V,u,0);solve(u);
}
inline void UesugiErii(){n=read(),D=read();if(D%2==0)--D;for(int i=1,u,v;i<n;i++)u=read(),v=read(),e[u].pb(v),e[v].pb(u);dfs(1,0),dsu(1,0);printf("%d\n",ans.size());for(pii i:ans)printf("%d %d\n",i.fi,i.se);
}
signed main(){//IO();int _=1;//cin>>_;for(;_;_--)UesugiErii();return 0;
}