【LOJ】#2722. 「NOI2018」情报中心

https://loj.ac/problem/2722

题解

考场上想了60分，但是由于自己不知道在怎么zz，我连那个ai<bi都没看到，误以为出题人没给lca不相同的部分分，然后觉得lca不同的部分想出来了要是相出lca相同的不就肝过去了……最后剩下的想法就是……为啥没给lca不同的呢……是我想错了？？？

剩了一个小时写暴力好像当时已经精神失常了，算了不想说了

出了考场写了一下60分，细节真是多到让我吐了，我代码能力疯狂下降吗，写了60分就370行了 出题人大毒瘤啊

从头到尾说一下部分分

前20给枚举链求链交的\(n^2\)暴力

再15分，似乎可以线段树，但是我归到S1的部分了

再15分c=0，可以枚举一个公共lca，求两个最小的v值，可以线段树合并，在lca处删除

再15分，就是相交部分是一条链的，这个枚举树上的每个点作为公共lca，然后我们就发现是

两条链的价值-代价 - 链交部分的价值

而链交部分的价值，就是这这个点深度 - 两条链中较低点lca的深度

忽略到枚举的点是常数

就是val1 - dis[lca1] + val2 或者 val2 - dis[lca2] + val1中的最大值即可，如果选了深度较小lca会被更新

直接线段树合并维护就好

猫锟卡乱搞了，大家散了吧

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <ctime>
#include <map>
#include <set>
#define fi first
#define se second
#define pii pair<int,int>
//#define ivorysi
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 50005
using namespace std;
typedef long long int64;
typedef double db;
typedef unsigned int u32;
template<class T>
void read(T &res) {
	res = 0;T f = 1;char c = getchar();
	while(c < '0' || c > '9') {
		if(c == '-') f = -1;
		c = getchar();
	}
	while(c >= '0' && c <= '9' ) {
		res = res * 10 - '0' + c;
		c = getchar();
	}
	res *= f;
}
template<class T>
void out(T x) {
	if(x < 0) {x = -x;putchar('-');}
	if(x >= 10) {
		out(x / 10);
	}
	putchar('0' + x % 10);
}
struct node {
	int to,next;int64 val;
}E[MAXN * 2];
struct qry_node {
	int u,v,lca;int64 val;
}qry[MAXN * 2];
int M,N,sumE,head[MAXN],fa[MAXN],dep[MAXN],pos[MAXN],st[MAXN * 2][20],idx,len[MAXN * 2],cnt;
int64 dis[MAXN],ans;
bool all_zero,all_lca_1,all_lca_distinct;
bool has[MAXN];
void add(int u,int v,int64 c) {
	E[++sumE].to = v;
	E[sumE].next = head[u];
	E[sumE].val = c;
	head[u] = sumE;
}
int min_dep(int a,int b) {
	return dep[a] < dep[b] ? a : b;
}
int max_dep(int a,int b) {
	return dep[a] > dep[b] ? a : b;
}
int lca(int a,int b) {
	a = pos[a];b = pos[b];
	if(a > b) swap(a,b);
	int l = len[b - a + 1];
	return min_dep(st[a][l],st[b - (1 << l) + 1][l]);
}
int64 Dist(int a,int b) {
	return dis[a] + dis[b] - 2 * dis[lca(a,b)];
}
void dfs(int u) {
	dep[u] = dep[fa[u]] + 1;
	st[++idx][0] = u;
	pos[u] = idx;
	for(int i = head[u] ;i ; i = E[i].next) {
		int v = E[i].to;
		if(v != fa[u]) {
			fa[v] = u;
			dis[v] = dis[u] + E[i].val;
			dfs(v);
			st[++idx][0] = u;
		}
	}
}
void Init() {
	sumE = 0;idx = 0;ans = -1e18;
	all_zero = 1;all_lca_1 = 1;all_lca_distinct = 1;
	memset(has,0,sizeof(has));
	for(int i = 1 ; i <= N ; ++i) head[i] = 0;
	read(N);
	int a,b;int64 c;
	for(int i = 1 ; i < N ; ++i) {
		read(a);read(b);read(c);
		add(a,b,c);add(b,a,c);
		if(c != 0) all_zero = 0;
	}
	dfs(1);
	for(int j = 1 ; j <= 19 ; ++j) {
		for(int i = 1 ; i <= idx ; ++i) {
			if(i + (1 << j) - 1 > idx) break;
			st[i][j] = min_dep(st[i][j - 1],st[i + (1 << j - 1)][j - 1]);
		}
	}
	read(M);
	for(int i = 1 ; i <= M ; ++i) {
		read(a);read(b);read(c);
		qry[i].u = a;qry[i].v = b;qry[i].lca = lca(a,b);
		qry[i].val = Dist(a,b) - c;
		if(has[qry[i].lca]) all_lca_distinct = 0;
		if(qry[i].lca != 1) all_lca_1 = 0;
		has[qry[i].lca] = 1;
	}
}
namespace task1 {
	void Solve() {
		for(int i = 1 ; i <= M ; ++i) {
			for(int j = 1 ; j <= M ; ++j) {
				if(i == j) continue;
				if(dep[qry[i].lca] < dep[qry[j].lca]) continue;
				int u = max_dep(qry[i].lca,lca(qry[i].u,qry[j].u));
				int v = max_dep(qry[i].lca,lca(qry[i].v,qry[j].v));
				if(u == v) {
					u = max_dep(qry[i].lca,lca(qry[i].u,qry[j].v));
					v = max_dep(qry[i].lca,lca(qry[i].v,qry[j].u));
				}
				if(u != v) {
					ans = max(ans,qry[i].val + qry[j].val - Dist(u,v));
				}
			}
		}

	}
	int check() {
		for(int i = 1 ; i <= M ; ++i) {
			for(int j = 1 ; j <= M ; ++j) {
				if(i == j) continue;
				if(dep[qry[i].lca] < dep[qry[j].lca]) continue;
				int u = max_dep(qry[i].lca,lca(qry[i].u,qry[j].u));
				int v = max_dep(qry[i].lca,lca(qry[i].v,qry[j].v));
				if(u == v) {
					u = max_dep(qry[i].lca,lca(qry[i].u,qry[j].v));
					v = max_dep(qry[i].lca,lca(qry[i].v,qry[j].u));
				}
				if(u != v) {
					if(ans == qry[i].val + qry[j].val - Dist(u,v)) {
						out(i);space;out(j);enter;
					}
				}
			}
		}
	}
};
namespace task2 {
	struct tr_node {
		int lc,rc;
		int64 maxa,maxb;
	}tr[MAXN * 40];
	int Ncnt,rt[MAXN];
	vector<int> st[MAXN],ed[MAXN];
	bool cmp(qry_node a,qry_node b) {
		return a.v < b.v;
	}
	void update(int u) {
		int64 la,lb,ra,rb;
		la = lb = ra = rb = -2e18;
		if(tr[u].lc) {
			la = tr[tr[u].lc].maxa;lb = tr[tr[u].lc].maxb;
		}
		if(tr[u].rc) {
			ra = tr[tr[u].rc].maxa;rb = tr[tr[u].rc].maxb;
		}
		tr[u].maxa = max(la,ra);
		tr[u].maxb = max(lb,rb);
	}
	int Merge(int u,int v,int64 val) {
		if(!u) return v;
		if(!v) return u;
		pii t[2] = {mp(tr[u].lc,tr[v].rc),mp(tr[u].rc,tr[v].lc)};
		for(int i = 0 ; i <= 1 ; ++i) {
			int a = t[i].fi,b = t[i].se;
			if(!a || !b) continue;
			ans = max(tr[a].maxa + tr[b].maxb + val,ans);
			ans = max(tr[a].maxb + tr[b].maxa + val,ans);
		}
		tr[u].lc = Merge(tr[u].lc,tr[v].lc,val);
		tr[u].rc = Merge(tr[u].rc,tr[v].rc,val);

		if(!tr[u].lc && !tr[u].rc) {
			tr[u].maxa = max(tr[u].maxa,tr[v].maxa);
			tr[u].maxb = max(tr[u].maxb,tr[v].maxb);
		}
		else update(u);
		return u;
	}
	void Insert(int &u,int L,int R,int pos,int64 va,int64 vb,bool on,int64 val) {
		if(!u) {
			u = ++Ncnt;
			tr[u].lc = tr[u].rc = 0;
			tr[u].maxa = tr[u].maxb = -2e18;
		}
		if(L == R) {
			if(on) {
				tr[u].maxa = va;tr[u].maxb = vb;
			}
			else {
				tr[u].maxa = max(tr[u].maxa,va);
				tr[u].maxb = max(tr[u].maxb,vb);
			}
			return;
		}
		int mid = (L + R) >> 1;
		if(pos <= mid) {
			Insert(tr[u].lc,L,mid,pos,va,vb,on,val);
			if(tr[u].rc) {
				ans = max(va + tr[tr[u].rc].maxb + val,ans);
				ans = max(vb + tr[tr[u].rc].maxa + val,ans);
			}
		}
		else {
			Insert(tr[u].rc,mid + 1,R,pos,va,vb,on,val);
			if(tr[u].lc) {
				ans = max(va + tr[tr[u].lc].maxb + val,ans);
				ans = max(vb + tr[tr[u].lc].maxa + val,ans);
			}
		}

		update(u);
	}
	void dfs(int u) {
		int s = st[u].size();
		int64 ma,mb;
		for(int i = 0 ; i < s ; ++i) {
			int id = st[u][i];
			if(dep[qry[id].lca] < dep[u]) {
				Insert(rt[u],1,N,dep[qry[id].lca],qry[id].val,qry[id].val + dis[qry[id].lca],0,-dis[u]);
			}
		}
		int64 tmp = -1e18;
		for(int i = head[u] ; i ; i = E[i].next) {
			int v = E[i].to;
			if(v != fa[u]) {
				dfs(v);
				if(rt[v]) Insert(rt[v],1,N,dep[u],-2e18,-2e18,1,-dis[u]);
				rt[u] = Merge(rt[u],rt[v],-dis[u]);
			}
		}
		ans = max(ans,tmp);
		if(dep[N] == N) {
			int s = ed[u].size();
			int64 v = 2e18;
			for(int i = 0 ; i < s ; ++i) {
				int id = ed[u][i];
				if(qry[id].u == qry[id].v) continue;
				ans = max(ans,qry[id].val - v);
				int64 t = -qry[id].val + 2 * (dis[qry[id].v] - dis[qry[id].u]);
				v = min(v,t);
			}
		}
	}
	void Solve() {
		Ncnt = 0;
		for(int i = 1 ; i <= N ; ++i) {
			rt[i] = 0;st[i].clear();ed[i].clear();
		}
		for(int i = 1 ; i <= M ; ++i) {
			if(qry[i].u > qry[i].v) swap(qry[i].u,qry[i].v);
		}
		sort(qry + 1,qry + M + 1,cmp);
		for(int i = 1 ; i <= M ; ++i) {
			st[qry[i].u].pb(i);
			st[qry[i].v].pb(i);
			ed[qry[i].lca].pb(i);
		}
		dfs(1);
	}
};
namespace task3 {
	vector<int> st[MAXN],ed[MAXN];
	struct tr_node {
		int lc,rc;
		int64 v,s;
	}tr[MAXN * 40];
	int rt[MAXN],Ncnt;
	void update(int u) {
		int64 lv,rv;
		lv = rv = -2e18;tr[u].s = -1e18;
		if(tr[u].lc) {lv = tr[tr[u].lc].v;tr[u].s = max(tr[u].s,tr[tr[u].lc].s);}
		if(tr[u].rc) {rv = tr[tr[u].rc].v;tr[u].s = max(tr[u].s,tr[tr[u].rc].s);}
		tr[u].v = max(lv,rv);
		tr[u].s = max(tr[u].s,lv + rv);
	}
	int Merge(int u,int v) {
		if(!u) return v;
		if(!v) return u;
		tr[u].lc = Merge(tr[u].lc,tr[v].lc);
		tr[u].rc = Merge(tr[u].rc,tr[v].rc);
		if(tr[u].lc || tr[u].rc) update(u);
		return u;
	}
	void Insert(int &u,int L,int R,int pos,int64 v) {
		if(!u) {
			u = ++Ncnt;
			tr[u].lc = tr[u].rc = 0;tr[u].v = -2e18;
			tr[u].s = -1e18;
		}
		if(L == R) {
			tr[u].v = v;return;
		}
		int mid = (L + R) >> 1;
		if(pos <= mid) Insert(tr[u].lc,L,mid,pos,v);
		else Insert(tr[u].rc,mid + 1,R,pos,v);
		update(u);
	}
	void dfs(int u) {
		for(int i = head[u] ; i ; i = E[i].next) {
			int v = E[i].to;
			if(v != fa[u]) {
				dfs(v);
				rt[u] = Merge(rt[u],rt[v]);
			}
		}
		int s = st[u].size();
		for(int i = 0 ; i < s ; ++i) {
			int id = st[u][i];
			if(dep[qry[id].lca] < dep[u]) {
				Insert(rt[u],1,M,id,qry[id].val);
			}
		}
		s = ed[u].size();
		for(int i = 0 ; i < s ; ++i) {
			int id = ed[u][i];
			Insert(rt[u],1,M,id,-2e18);
		}
		if(rt[u]) {
			ans = max(ans,tr[rt[u]].s);
		}

	}
	void Solve() {
		Ncnt = 0;
		for(int i = 1 ; i <= N ; ++i) {
			st[i].clear();ed[i].clear();rt[i] = 0;
		}
		for(int i = 1 ; i <= M ; ++i) {
			st[qry[i].u].pb(i);
			st[qry[i].v].pb(i);
			ed[qry[i].lca].pb(i);
		}
		dfs(1);
	}
};
namespace task4 {
	vector<int> st[MAXN];
	pii C[MAXN];
	int64 V[MAXN * 4];
	int f[MAXN * 4],cnt;
	int64 get_dist(int a,int b) {
		return Dist(f[a],f[b]) + V[a] + V[b];
	}
	void Merge(pii &path,int p) {
		if(!p) return;
		if(!path.se) path.se = p;
		else if(!path.fi) path.fi = p;
		else {
			int64 x1 = get_dist(p,path.fi),x2 = get_dist(p,path.se),x3 = get_dist(path.fi,path.se);
			if(x1 >= max(x2,x3)) {
				path = mp(p,path.fi);
			}
			else if(x2 > max(x1,x3)) {
				path = mp(p,path.se);
			}
		}
	}
	void dfs(int u) {
		int s = st[u].size();
		C[u] = mp(0,0);
		if(u != 1) {
			for(int i = 0 ; i < s ; ++i) {
				Merge(C[u],st[u][i]);
				if(C[u].fi && C[u].se) {
					ans = max(ans,get_dist(C[u].fi,C[u].se) / 2 - dis[u]);
				}
			}
		}
		for(int i = head[u] ; i ; i = E[i].next) {
			int v = E[i].to;
			if(v != fa[u]) {
				dfs(v);
				int t1[2] = {C[u].fi,C[u].se};
				int t2[2] = {C[v].fi,C[v].se};
				if(u != 1) {
					for(int j = 0 ; j <= 1 ; ++j) {
						for(int k = 0 ; k <= 1 ; ++k) {
							int s = t1[j],t = t2[k];
							if(!s || !t) continue;
							ans = max(ans,get_dist(s,t) / 2 - dis[u]);
						}
					}
				}
				Merge(C[u],C[v].fi);Merge(C[u],C[v].se);
			}
		}
	}
	void Solve() {
		for(int i = 1 ; i <= N ; ++i) {
			st[i].clear();
		}
		cnt = 0;
		for(int i = 1 ; i <= M ; ++i) {
			qry[i].val = -qry[i].val + Dist(qry[i].u,qry[i].v);
			V[++cnt] = Dist(qry[i].u,qry[i].v) - 2 * qry[i].val + dis[qry[i].u];
			f[cnt] = qry[i].v;
			st[qry[i].u].pb(cnt);
			V[++cnt] = Dist(qry[i].u,qry[i].v) - 2 * qry[i].val + dis[qry[i].v];
			f[cnt] = qry[i].u;
			st[qry[i].v].pb(cnt);
		}
		dfs(1);
	}
};
namespace task5 {
	vector<pii > st[MAXN];
	map<int,pii > dp[MAXN];
	int64 V[MAXN * 4];
	int f[MAXN * 4],cnt;
	int64 get_dist(int a,int b) {
		return Dist(f[a],f[b]) + V[a] + V[b];
	}
	void Merge(pii &path,int p) {
		if(!p) return;
		if(!path.se) path.se = p;
		else if(!path.fi) path.fi = p;
		else {
			int64 x1 = get_dist(p,path.fi),x2 = get_dist(p,path.se),x3 = get_dist(path.fi,path.se);
			if(x1 >= max(x2,x3)) {
				path = mp(p,path.fi);
			}
			else if(x2 > max(x1,x3)) {
				path = mp(p,path.se);
			}
		}
	}
	void dfs(int u) {
		int s = st[u].size();
		for(int i = 0 ; i < s ; ++i) {
			pii t = st[u][i];
			if(!dp[u].count(t.se)) {
				dp[u][t.se] = mp(0,0);
			}
			Merge(dp[u][t.se],t.fi);
			if(dp[u][t.se].fi && dp[u][t.se].se) {

				ans = max(ans,get_dist(dp[u][t.se].fi,dp[u][t.se].se) / 2 - dis[u] + dis[t.se]);
			}
		}
		for(int i = head[u] ; i ; i = E[i].next) {
			int v = E[i].to;
			if(v != fa[u]) {
				dfs(v);
				if(dp[v].size() > dp[u].size()) swap(dp[u],dp[v]);
				map<int,pii >::iterator it = dp[v].begin();
				while(it != dp[v].end()) {
					if(u != it->fi && dp[u].count(it->fi)) {
						int t1[2] = {dp[u][it->fi].fi,dp[u][it->fi].se};
						int t2[2] = {dp[v][it->fi].fi,dp[v][it->fi].se};
						for(int j = 0 ; j <= 1 ; ++j) {
							for(int k = 0 ; k <= 1 ; ++k) {
								int s = t1[j],t = t2[k];
								if(!s || !t) continue;
								ans = max(ans,get_dist(s,t) / 2 - dis[u] + dis[it->fi]);

							}
						}
						Merge(dp[u][it->fi],it->se.fi);
						Merge(dp[u][it->fi],it->se.se);
					}
					else {
						dp[u][it->fi] = it->se;
					}
					++it;
				}
				dp[v].clear();
			}
		}
		dp[u].erase(u);
	}
	void Solve() {
		cnt = 0;
		for(int i = 1 ; i <= N ; ++i) {
			st[i].clear();dp[i].clear();
		}
		for(int i = 1 ; i <= M ; ++i) {
			qry[i].val = -qry[i].val + Dist(qry[i].u,qry[i].v);
			V[++cnt] = Dist(qry[i].u,qry[i].v) - 2 * qry[i].val + dis[qry[i].u] - dis[qry[i].lca];
			f[cnt] = qry[i].v;
			if(qry[i].u != qry[i].lca) st[qry[i].u].pb(mp(cnt,qry[i].lca));
			V[++cnt] = Dist(qry[i].u,qry[i].v) - 2 * qry[i].val + dis[qry[i].v] - dis[qry[i].lca];
			f[cnt] = qry[i].u;
			if(qry[i].v != qry[i].lca) st[qry[i].v].pb(mp(cnt,qry[i].lca));
		}
		dfs(1);
	}
};
int main() {
#ifdef ivorysi
	freopen("center4.in","r",stdin);
#else
	freopen("center.in","r",stdin);
	freopen("center.out","w",stdout);
#endif
	for(int i = 2 ; i <= 100000 ; ++i) len[i] = len[i / 2] + 1;
	int T;
	read(T);
	cnt = 0;
	while(T--) {
		Init();
		if(M <= 300) task1::Solve();
		else if(all_lca_1) task4::Solve();
		else if(dep[N] == N) task2::Solve();
		else if(all_zero) task3::Solve();
		else if(all_lca_distinct) task2::Solve();
		else {
			task2::Solve();
			task5::Solve();
		}

		if(ans <= -1e18) puts("F");
		else {out(ans);enter;}
	}
	return 0;
}

直接调用task2和task5可以通过，然鹅我分部分分写的话直接用……task2处理一条链上同时所有lca为1的路径似乎有问题？懒得debug了= =

12.8K写得我真的非常开心

再20分的话，就非常神仙了

有个性质是链并的两倍等于两条链长 + u1 u2距离 + v1 v2距离

这时候再沿用前面思路的话就非常鸽

我们拆个式子

枚举u1和u2的lca是r

然后答案就是

dis[u_1] + dis[u_2] - 2 * dis[r] + (1链长价值 - 代价) - (2链长价值 - 代价） + dist(v1,v2)

我们多个附加点p1连向v1，边权是链长价值-代价 + dis[u_1]

当遇到u_1 的时候，加进去p_1,就相当于对于一个形态固定的树，加进去一个点可使用，找两个点集中各一个点的一条最长链

因为只有增加操作，那么两个点集中的各一个端点必然是两个点集中各自最长链的端点

最后20分，只要做一遍S1，再记录一下lca做一下S2，数组启发式合并就行……

我代码写的好长

NOI考完，我想我知道

我大概是LN的绝望了