[CF611H]New Year and Forgotten Tree

题目

传送门 to CF

思路

着实很佩服，这种需要用 归纳法 证明的结论，做出来的人是怎么想到的……

用归纳法证明，满足条件的树总可以是如下形式：

• $1,10,100,\dots ,10^{m-1}(m=\lceil \lg (n+1)\rceil )$ 构成一棵树。
• 其余点都是叶子，且与这 $m$ 个点中恰好一个相连。

因为，任取一个满足条件的树，任意删除一个叶子，设其长度为 $a$，其父节点长度为 $b$ 。若 $a$ 并非只剩一个，那么新树可以构造成上述形式，然后让 $a$ 作为叶子连向 $10^{b-1}$ 即可。

如果 $a$ 是唯一的一个了呢？那么可以构造出 $(m-1)$ 个点作为 “核” 的类似形式，去掉了 $10^{a-1}$ 罢了。然后把 $10^{a-1}$ 加入，与 $10^{b-1}$ 相连，仍然满足条件。

上面的证明，只能归纳法；在整棵树上，直接调整成该 “标准形式” 是困难的（因为我不会搞）。尽管这个结论似乎足够合理，我仍然疑惑怎样才能发见这样的性质。

结论得证后，我们可以 $2^{\frac{m(m-1)}{2}}$ 枚举 “核” 的连边情况（但其实只有 $m^{m-2}$ 个不同的树），然后 $a\leftrightarrow b$ 的边，可以选择其中一个做叶子，这样就会让其数量增多 $1$ 。所以这是个网络流嘛（每条边分配 “做叶子” 数量）。

时间复杂度 $\mathcal{O}(2^{\frac{m(m-1)}{2}}{m}^2+m^{m-2}\cdot m^6)=\mathcal{O}(m^2\sqrt{2^{m^2-m}}+m^{m+4})$，完全没问题。

代码

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long llong;
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar())
		if(c == '-') f = -f;
	for(; isdigit(c); c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MAXN = 10, INF = 0x3fffffff;
char str[MAXN];
int g[MAXN][MAXN], cnt[MAXN];

namespace Network{
	struct Edge{
		int to, nxt, val;
		Edge(int _t,int _n,int _v)
			:to(_t),nxt(_n),val(_v){}
		Edge() = default;
	};
	Edge e[MAXN*MAXN<<1];
	int head[MAXN*MAXN], cntEdge;
	void addEdge(int a,int b,int c){
		e[cntEdge] = Edge(b,head[a],c);
		head[a] = cntEdge ++;
		e[cntEdge] = Edge(a,head[b],0);
		head[b] = cntEdge ++;
	}
	void clear(int n){
		memset(head+1,-1,n<<2), cntEdge = 0;
	}
	int dis[MAXN*MAXN], cur[MAXN*MAXN];
	bool bfs(const int source,const int sink){
		static int q[MAXN*MAXN]; int *fro = q, *bac = q+1;
		memset(dis+1,-1,sink<<2), dis[q[1] = source] = 0;
		for(int x; fro!=bac; ){
			if((x = *(++ fro)) == sink) return true;
			for(int i=head[x]; ~i; i=e[i].nxt)
				if(e[i].val && !(~dis[e[i].to])){
					dis[e[i].to] = dis[x]+1;
					++ bac, *bac = e[i].to;
				}
		}
		return false;
	}
	int dfs(int x,int inFlow,const int sink){
		int sum = 0; if(x == sink) return inFlow;
		for(int &i=cur[x]; ~i; i=e[i].nxt)
			if(e[i].val && dis[e[i].to] == dis[x]+1){
				int d = dfs(e[i].to,min(inFlow-sum,e[i].val),sink);
				e[i].val -= d, e[i^1].val += d;
				if((sum += d) == inFlow) return sum;
			}
		dis[x] = -1; return sum;
	}
	int dinic(const int source,const int sink){
		int res = 0;
		while(bfs(source,sink)){
			memcpy(cur+1,head+1,sink<<2);
			res += dfs(source,INF,sink);
		}
		return res;
	}
}

int zxy[MAXN], boss[MAXN];
inline void hang(int x,int y,int c){
	while(c --) ++ zxy[x], printf("%d %d\n",zxy[x],boss[y]);
}
bool attempt(const int m,const int N){
	const int source = m+N+1, sink = source+1;
	using namespace Network; clear(sink);
	int expect = 0; rep(i,1,m) expect += cnt[i];
	for(int i=1,id=1; i!=m; ++i)
		for(int j=i+1; j<=m; ++j,++id){
			if(g[i][j] < 0) return false; // invalid
			addEdge(source,id,g[i][j]);
			addEdge(id,i+N,INF), addEdge(id,j+N,INF);
		}
	rep(i,1,m) addEdge(i+N,sink,cnt[i]);
	if(dinic(source,sink) != expect) return false;
	zxy[1] = boss[1] = 1; // pointer and root
	rep(i,2,m) zxy[i] = boss[i] = zxy[i-1]*10;
	for(int i=1,id=0; i!=m; ++i)
		for(int j=i+1; j<=m; ++j,++id){
			hang(i,j,e[(3*id+1)<<1|1].val);
			hang(j,i,e[(3*id+2)<<1|1].val);
		}
	return true; // we make it, dude!
}

namespace UFS{
	int fa[MAXN];
	void init(int n){ rep(i,1,n) fa[i] = i; }
	inline int find(int a){
		if(fa[a] == a) return a;
		return fa[a] = find(fa[a]);
	}
	bool merge(int a,int b){
		if(find(a) == find(b)) return false;
		return fa[fa[a]] = fa[b], true;
	}
}
int main(){
	int n = readint();
	for(int i=1; i!=n; ++i){
		scanf("%s",str); int a = int(strlen(str));
		scanf("%s",str); int b = int(strlen(str));
		++ g[a][b], ++ g[b][a];
	}
	for(int i=1,v=10,t=1; i<=n; ++i){
		if(i == v) v *= 10, ++ t;
		++ cnt[t]; // number of digits
	}
	int m = 6; while(!cnt[m]) -- m;
	rep(i,1,m) cnt[i] -= (g[i][i]>>1)+1;
	rep(i,1,m) if(cnt[i] < 0) return puts("-1"), 0;
	const int N = m*(m-1)>>1;
	for(int S=0; S!=(1<<N); ++S){
		int ok = 0; UFS::init(m);
		for(int i=1,id=0; i!=m; ++i)
			for(int j=i+1; j<=m; ++j,++id){
				if(!(S>>id&1)) continue;
				if(UFS::merge(i,j)) ++ ok;
				else ok = -0xffff; // -INF
				-- g[i][j]; // always do it
			}
		if(ok == m-1 && attempt(m,N)){
			for(int i=1,id=0; i!=m; ++i)
				for(int j=i+1; j<=m; ++j,++id){
					if(!(S>>id&1)) continue;
					printf("%d %d\n",boss[i],boss[j]);
				}
			rep(i,1,m) for(g[i][i]>>=1; g[i][i]; --g[i][i])
				++ zxy[i], printf("%d %d\n",boss[i],zxy[i]);
			return 0; // we make it!
		}
		for(int i=1,id=0; i!=m; ++i)
			for(int j=i+1; j<=m; ++j,++id)
				g[i][j] += (S>>id&1); // restore
	}
	puts("-1");
	return 0;
}