【UOJ】Round48:Goodbye Wuxu题解(A-C)

传送门:
Goodbye Wuxu
题解
D,E暂咕

---

A. 新年的拯救计划

一共$\frac{n(n-1)}{2}$条边，所以$m\le \lfloor \frac{n}{2}\rfloor$。

上限是一定可以卡满的：考虑构造$\lfloor \frac{n}{2}\rfloor$条起终点均不同的链，分奇偶讨论。
(然后就想歪了，还是没想到怎么$n^2$复杂度以内构造这么多条链)

一档部分分叫“$n$是素数”：

可以联想到对于整数$1\le k<n$，$\gcd (k,n-k)=1$。

由于$n$必然为奇数($n\ge 3$)，所以可以构造$\lfloor \frac{n}{2}\rfloor$棵树，对于第$i(1\le i\le \lfloor \frac{n}{2}\rfloor )$棵树，将所有$|u-v|=i$或$|u-v|=n-i$连边(连出来是个环，随便断一条边即可)。

再考虑$n$为偶数的情况：

假设已经构造出了第一棵树$T_0$。
对于每条边$(u,v)$，在第$1\le i<\frac{n}{2}$棵树中连接$((u+i)modn,(v+i)modn)$。

对于一条边$(u,v)(u<v)$，定义其长度为$\min (v-u,u-v+n)$，考虑每条边不断循环右移$[0,\frac{n}{2})$中长度变化的过程：

长度相同且$<\frac{n}{2}$的边最多可以存在两条：$(u,v)$和$((u+\frac{n}{2})modn,(v+\frac{n}{2})modn)$。
长度为$\frac{n}{2}$的边只能存在一条。

所以对于$T_0$，构造$2\times (\frac{n}{2}-1)+1=n-1$条边，下面是一种例子：
$1$连向$[2,\frac{n}{2}+1]$之间的所有点，$\frac{n}{2}+1$连向$[\frac{n}{2}+2,n]$之间的所有点。

$n$为奇数时范围反而变宽了(长度为$\lfloor \frac{n}{2}\rfloor$的边也能存在两条)，取同样的构造方法即可。

(A题都做不出来，给跪了)

---

B. 新年的Dog划分

假设二分图左右点集分别为$S,T$。

首先考虑怎么暴力：

$2^n$枚举左右点集合$A,B$，询问时只保留$AB$之间的连边，若是二分图，则必然存在一种情况的答案是连通：

假设$A\cap S̸=\varphi$。
若$A\cap T̸=\varphi$，则$A\cap S$与$A\cap T$不连通(它们分别只能和$B\cap T$与$B\cap S$相连)，矛盾，所以$A\cap T=\varphi$。
若$B\cap S̸=\varphi$，则$A\cap S$与$B\cap S$不连通，矛盾，所以$B\cap S=\varphi$。

所以$A=S,B=T$。

正解：

只需要找到原图的一个生成树：

从$1$开始向外$BFS$维护当前连通块。
每次取出队顶元素$x$，不断在所有未加入连通块的点中二分是否存在最小的$y$，使得删掉连通块与这个点之间的连边之后图不连通，$(x,y)$则是生成树上的一条边，询问次数上限$O(n\log n)$。

构造生成树后黑白点染色得到二分图，还需要判断是否是二分图：
删去二分图左右部之间的所有连边(生成树上的边除外)，若不是二分图，则必然在树上有环，则枚举删掉一条树边判断图是否连通即可。

在提交记录里翻到一个十分优秀简洁的写法：

每次直接维护当前连通块中二分图左右部的点，二分找到不在连通块内且删去该点与连通块连边后图不连通的点$y$，分别判断删去左部/右部与$y$连边后是否连通，若两边删去均连通，则不是二分图，否则就找到了$y$所在部分(左/右)。

#include <bits/stdc++.h>
#define pb push_back
#define pii pair<int,int>
#define mkp make_pair
using namespace std;
#include "graph.h"
const int N=205;
int col[N];
map<int,bool> result;

vector<int> check_bipartite(int n)
{
	int i,j,k,l,r,mid,res,t;
	bool isb=true;col[0]=1;
	for(i=1;i<n;++i){
		vector<int>s;
		for(j=1;j<n;++j) if(!col[j]) s.pb(j);
		l=0,r=s.size()-1;res=s.size();
		for(;l<=r;){
			mid=(l+r)>>1;
			vector<pair<int,int> > le;
			for(j=mid;j<s.size();++j)
				for(k=0;k<n;++k) if(col[k]) le.pb(mkp(s[j],k));
			query(le)?r=mid-1:l=(res=mid)+1;
		}
		result[-1]=result[1]=false;
		for(t=-1;t<=1;t+=2){
			vector<pair<int,int> > le;
			for(j=res+1;j<s.size();++j)
				for(k=0;k<n;++k) if(col[k])le.pb(mkp(s[j],k));
			for(k=0;k<n;++k) if(col[k]==t)le.pb(mkp(s[res],k));
			result[t]=query(le);
		}
		if(result[-1]&&result[1]){isb=false;break;}
		col[s[res]]=result[1]?1:-1;
	}
	vector<int> ans;
	if(isb)
		for(i=0;i<n;++i)
			if(col[i]>0) ans.push_back(i);
	return ans;
}

---

C. 新年的小黄鸭

$35pts$的$n^2$暴力：

$f[i][j]$表示$i$点向上的连续重链长度为$j$时，$i$子树内的最优解。
转移时直接枚举重儿子。

#include <bits/stdc++.h>
#define pb push_back
using namespace std;
const int N=5005;

int lg[N],n,sz[N],f[N][N];
vector<int>g[N];

inline void dn(int &x,int y){if(y<x) x=y;}
void dfs(int x,int fr)
{
	int i,sum=0;sz[x]=1;
	for(int y:g[x]) if(y^fr){
		dfs(y,x);sz[x]+=sz[y];sum+=f[y][0];
		for(i=0;i+1<n;++i) dn(f[x][i],f[y][i+1]-f[y][0]-(i?sz[y]*lg[i]:0));
	}
	for(i=0;i<n;++i) f[x][i]+=(sum+sz[x]*lg[i]);
}

int main(){
	int i,x,y;lg[0]=1;
	scanf("%d",&n);
	for(i=1;i<n;i<<=1) lg[i+1]=1;
	for(i=1;i<n;++i) lg[i]+=lg[i-1];
	for(i=1;i<n;++i){scanf("%d%d",&x,&y);g[x].pb(y);g[y].pb(x);}
	dfs(1,0);printf("%d",f[1][0]-n);
	return 0;
}

正解：

设$trans(x)=\lceil {\log }_{2}x\rceil +1$。

观察到$f[i][j]$中对于$trans(j)$相等的$j$其实可以用同一个$f[i][k]$来表示，所以只需要记$f[i][trans(j)]$的值，状态就变成$n\log n$的了。

考虑转移：
对于$f[i][j]$，枚举$i$重链上(子树内)第一个满足$j$的值不同或是叶结点的点，设其为$y$，则$f[i][j]=f[y][j+1]+f[y到i路径上所有轻儿子][0]+(y到i路径上除y外所有点的值)$。

……

还是比较玄学，算了，直接讲做法吧：

首先预处理出来每个点可以由它子树内哪些点转移而来(所有距离$=1$或$2^i+1$)，记为$nt[x]$数组，总数量级别是$O(n\log n)$的，且按$dfs$序给每个叶结点标号，$[i{n}_x,ou{t}_x]$表示在子树$x$中的叶节点范围。

设$dp[x]=f[x][0]-sz[x]$(即$x$为根的答案，叶结点的$dp$值为$0$)。
对于$dp[x]$，本质上是选中一个子树内叶结点$y$，$x$到$y$这条路径就是重链。$dp[x]=min(v(x到y路径上所有点))(i{n}_x\le y\le ou{t}_x)$。

$$\begin{gathered} v(y)=trans(dis(x,y))+(\sum _{t\in son[fathe{r}_y]}dp[t]+sz[t](1+trans(dis(x,t))))-dp[y]-sz[y](1+trans(dis(x,y))) \\ =(\sum _{t\in son[fathe{r}_y]}dp[t]+sz[t])-dp[y]-sz[y]+(sz[fathe{r}_y]-sz[y])trans(dis(x,y)) \end{gathered}$$。

对于前一部分：$\sum ((\sum _{t\in son[fathe{r}_y]}dp[t]+sz[t])-dp[y]-sz[y])$直接在线段树上按关于叶结点的$dfs$序维护即可。

对于后一部分：实际上就是$y$和所有轻儿子子树这些点到根的贡献为$trans(x,y)$，
而$y$子树中的重链部分的贡献还要另算，轻链部分子树中的$v()$会算到。
但注意$trans(x,y)$只有$\log n$中取值，我们把将一个点$\times trans(x,y)$转成对于每个点的在它的$1,2^0+1,2^1+1,...,2^k+1$级祖先处分别被算一次。
也就是线段树中将$nt[x]$中所有点$q$在其对应的范围$[i{n}_q,ou{t}_q]$内$+sz[q]$。

$dp[x]$就是查询线段树$[i{n}_x,ou{t}_x]$内最小值。

面向代码做题(大雾)

#include<bits/stdc++.h>
#define lc k<<1
#define rc k<<1|1
#define mid ((l+r)>>1)
#define pb push_back
using namespace std;
const int N=1e5+10;

int n,f[N][17],in[N],ot[N],sz[N],dfn,dp[N];
int mn[N<<2],lzy[N<<2];
vector<int>g[N],nt[N];

inline void ad(int k,int l,int r,int L,int R,int v)
{
	if(L<=l && r<=R) {mn[k]+=v;lzy[k]+=v;return;}
	if(L<=mid) ad(lc,l,mid,L,R,v);
	if(R>mid) ad(rc,mid+1,r,L,R,v);
	mn[k]=min(mn[lc],mn[rc])+lzy[k];
}

inline int ask(int k,int l,int r,int L,int R)
{
	if(L<=l && r<=R) return mn[k];
	if(R<=mid) return ask(lc,l,mid,L,R);
	if(L>mid) return ask(rc,mid+1,r,L,R);
	return min(ask(lc,l,mid,L,R),ask(rc,mid+1,r,L,R))+lzy[k];
}

void dfs1(int x,int fr)
{
	int i;f[x][0]=fr;if(fr) nt[fr].pb(x);
	for(i=1;i<17;++i) f[x][i]=f[f[x][i-1]][i-1];
	for(i=0;i<17;++i) if(f[f[x][i]][0]) nt[f[f[x][i]][0]].pb(x);
	sz[x]=1;in[x]=dfn+1;if(g[x].size()==1 && fr) dfn++;
	for(int y:g[x]) if(y^fr) {dfs1(y,x);sz[x]+=sz[y];}
	ot[x]=dfn;
}

void dfs2(int x,int fr)
{
	int sum=0;
	for(int y:g[x]) if(y^fr) {dfs2(y,x);sum+=dp[y]+sz[y];}
	for(int y:g[x]) if(y^fr) ad(1,1,dfn,in[y],ot[y],sum-dp[y]-sz[y]);
	for(int y:nt[x]) ad(1,1,dfn,in[y],ot[y],sz[y]);
	dp[x]=ask(1,1,dfn,in[x],ot[x]);
	for(int y:nt[x]) ad(1,1,dfn,in[y],ot[y],-sz[y]);
}

int main(){
	int i,x,y;scanf("%d",&n);
	for(i=1;i<n;++i) {scanf("%d%d",&x,&y);g[x].pb(y);g[y].pb(x);}
	dfs1(1,0);dfs2(1,0);printf("%d",dp[1]);
	return 0;
}