严格次小生成树[BJWC2010] (树链剖分,倍增,最小生成树)
题目链接
Solution
有几点关键,首先,可以证明次小生成树一定是由最小生成树改变一条边而转化来.
所以需要枚举所有非最小生成树的边\((u,v)\).并且找到 \(u\) 到 \(v\) 的边中最大边和次大边.
为什么要找次大边呢?? 因为可能最大边与要替换的边长度相等,那么这种条件生成的便不是严格的次小生成树.
然后找到 \(u,v\) 之间的次大和最大边有两种方式:
- 树链剖分+线段树维护
剖分最小生成树,然后用线段树维护.
此时线段树节点转移时要考虑左右节点的次大和最大的 \(4\) 个值.
时间复杂度: \(O(mlogn)\) . - 树上 \(st\) 表
与倍增求 \(LCA\) 的方式类似,倍增维护信息然后找 \(LCA\) 即可.
时间复杂度: \(O(mlogn)\) .
然后似乎还可以用 \(LCT\) 来做.时间复杂度也差不多.
Code
倍增版本:
#include<bits/stdc++.h>
#define N 400010
#define M 900010
#define INF 2147483647000000
#define ll long long
using namespace std;
struct edge{
ll u,v,d;
ll next;
}G[N<<1];
ll tot=0;
ll head[N];
inline void addedge(ll u,ll v,ll d)
{
G[++tot].u=u,G[tot].v=v,G[tot].d=d,G[tot].next=head[u],head[u]=tot;
G[++tot].u=v,G[tot].v=u,G[tot].d=d,G[tot].next=head[v],head[v]=tot;
}
ll bz[N][19];
ll maxi[N][19];
ll mini[N][19];
ll deep[N];
inline void dfs(ll u,ll fa)
{
bz[u][0]=fa;
for(ll i=head[u];i;i=G[i].next)
{
ll v=G[i].v;
if(v==fa)continue;
deep[v]=deep[u]+1ll;
maxi[v][0]=G[i].d;
mini[v][0]=-INF;
dfs(v,u);
}
}
ll n;
inline void cal()
{
for(ll i=1;i<=18;++i)
for(ll j=1;j<=n;++j)
{
bz[j][i]=bz[bz[j][i-1]][i-1];
maxi[j][i]=max(maxi[j][i-1],maxi[bz[j][i-1]][i-1]);
mini[j][i]=max(mini[j][i-1],mini[bz[j][i-1]][i-1]);
if(maxi[j][i-1]>maxi[bz[j][i-1]][i-1])mini[j][i]=max(mini[j][i],maxi[bz[j][i-1]][i-1]);
else if(maxi[j][i-1]<maxi[bz[j][i-1]][i-1])mini[j][i]=max(mini[j][i],maxi[j][i-1]);
}
}
inline ll LCA(ll x,ll y)
{
if(deep[x]<deep[y])swap(x,y);
for(ll i=18;i>=0;--i)
if(deep[bz[x][i]]>=deep[y])
x=bz[x][i];
if(x==y)return x;
for(ll i=18;i>=0;--i)
if(bz[x][i]^bz[y][i])
x=bz[x][i],y=bz[y][i];
return bz[x][0];
}
inline ll qmax(ll u,ll v,ll maxx)
{
ll Ans=-INF;
for(ll i=18;i>=0;--i)
{
if(deep[bz[u][i]]>=deep[v])
{
if(maxx!=maxi[u][i])Ans=max(Ans,maxi[u][i]);
else Ans=max(Ans,mini[u][i]);
u=bz[u][i];
}
}
return Ans;
}
inline void read(ll &x)
{
x=0;
char ch=getchar();
while(ch<'0'||ch>'9')ch=getchar();
while(ch>='0'&&ch<='9')x=x*10+(ch^48),ch=getchar();
}
ll m;
edge A[M<<1];
inline bool cmp(edge x,edge y)
{
return x.d<y.d;
}
ll Father[N];
inline ll Get_Father(ll x)
{
return (x==Father[x]) ? x : Father[x]=Get_Father(Father[x]);
}
bool B[M<<1];
int main()
{
read(n),read(m);
for(ll i=1;i<=m;++i)
{
read(A[i].u),read(A[i].v),read(A[i].d);
}
sort(A+1,A+m+1,cmp);
for(ll i=1;i<=n;++i)
Father[i]=i;
ll Cnt=0ll;
for(ll i=1;i<=m;++i)
{
ll Father_u=Get_Father(A[i].u);
ll Father_v=Get_Father(A[i].v);
if(Father_u!=Father_v)
{
Cnt+=A[i].d;
Father[Father_u]=Father_v;
addedge(A[i].u,A[i].v,A[i].d);
B[i]=true;
}
}
mini[1][0]=-INF;
deep[1]=1;
dfs(1,-1);
cal();
ll Ans=INF;
for(ll i=1;i<=m;++i)
{
if(!B[i])
{
ll u=A[i].u;
ll v=A[i].v;
ll d=A[i].d;
ll lca=LCA(u,v);
ll maxu=qmax(u,lca,d);
ll maxv=qmax(v,lca,d);
Ans=min(Ans,Cnt-max(maxu,maxv)+d);
}
}
printf("%lld",Ans);
return 0;
}
树剖版本:
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#define MAXN 100010
#define MAXM 300010
#define pos(l, r) ((l+r) | (l != r))
using namespace std;
struct Edge {
int u, v, w, f, next;
bool operator < (const Edge &A) const { return w < A.w; }
} e[MAXM*2];
struct node {
int m1, m2;
} t[MAXN*2];
int n, m, h[MAXN], dep[MAXN], son[MAXN], w[MAXN], tot, fa[MAXN], par[MAXN], cnt, id[MAXN], top[MAXN], a[MAXN], TOT;
long long MST, secMST = 1e15;
inline int max(int a, int b) {
return a > b ? a : b;
}
inline int secmax(int a, int b, int c, int d) {
int tmp[4] = {a, b, c, d};
sort(tmp, tmp+4);
for (int i = 2; i >= 0; --i) {
if (tmp[i] != tmp[i+1]) return tmp[i];
}
}
void addEdge(int ui, int vi, int wi, int fi) {
e[++tot] = (Edge) {ui, vi, wi, fi, h[ui]};
h[ui] = tot;
}
int find(int x) {
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void dfs(int u) {
w[u] = 1;
for (int i = h[u]; i; i = e[i].next) {
if (!w[e[i].v]) {
dep[e[i].v] = dep[u]+1;
par[e[i].v] = u;
a[e[i].v] = e[i].w;
dfs(e[i].v);
w[u] += w[e[i].v];
if (w[son[u]] < w[e[i].v]) son[u] = e[i].v;
}
}
}
void init(int u, int p) {
id[u] = ++cnt;
top[u] = p;
if (son[u]) init(son[u], p);
for (int i = h[u]; i; i = e[i].next) {
if (!top[e[i].v]) init(e[i].v, e[i].v);
}
}
void modify(int l, int r, int x, int d, int p) {
if (l == r) {
t[p].m1 = d;
t[p].m2 = 0;
} else {
int mid = (l+r)>>1, lc = pos(l, mid), rc = pos(mid+1, r);
if (x <= mid) modify(l, mid, x, d, lc);
else modify(mid+1, r, x, d, rc);
t[p].m2 = secmax(t[lc].m1, t[lc].m2, t[rc].m1, t[rc].m2);
t[p].m1 = max(t[lc].m1, t[rc].m1);
}
}
node query(int l, int r, int x, int y, int p) {
if (x <= l && r <= y) return t[p];
int mid = (l+r)>>1, lc = pos(l, mid), rc = pos(mid+1, r);
if (x <= mid && y > mid) {
node t1 = query(l, mid, x, y, lc), t2 = query(mid+1, r, x, y, rc);
return (node) {max(t1.m1, t2.m1), secmax(t1.m1, t1.m2, t2.m1, t2.m2)};
} else if (x <= mid) return query(l, mid, x, y, lc);
else return query(mid+1, r, x, y, rc);
}
node solve(int u, int v) {
int pu = top[u], pv = top[v];
node res = (node) {0, 0};
while (pu != pv) {
if (dep[pu] < dep[pv]) {
swap(pu, pv);
swap(u, v);
}
node tmp = query(1, n, id[pu], id[u], pos(1, n));
res.m2 = secmax(res.m1, res.m2, tmp.m1, tmp.m2);
res.m1 = max(res.m1, tmp.m1);
u = par[pu];
pu = top[u];
}
if (u == v) return res;
if (dep[u] < dep[v]) swap(u, v);
node tmp = query(1, n, id[v]+1, id[u], pos(1, n));
res.m2 = secmax(res.m1, res.m2, tmp.m1, tmp.m2);
res.m1 = max(res.m1, tmp.m1);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, ui, vi, wi; i <= m; ++i) {
scanf("%d%d%d", &ui, &vi, &wi);
addEdge(ui, vi, wi, 0);
}
sort(e+1, e+tot+1);
TOT = tot;
memset(h, 0, sizeof(h));
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1, k; i <= TOT; ++i) {
int ux = find(e[i].u), uy = find(e[i].v);
if (ux != uy) {
fa[ux] = uy;
MST += e[i].w;
e[i].f = 1;
e[i].next = h[e[i].u];
h[e[i].u] = i;
addEdge(e[i].v, e[i].u, e[i].w, 1);
k++;
}
if (k == n-1) break;
}
dfs(1);
init(1, 1);
for (int i = 1; i <= n; ++i) modify(1, n, id[i], a[i], pos(1, n));
for (int i = 1; i <= TOT; ++i) {
if (!e[i].f) {
node cross = solve(e[i].u, e[i].v);
long long tmp = MST+e[i].w-(cross.m1 == e[i].w ? cross.m2 : cross.m1);
if (tmp > MST && tmp < secMST) secMST = tmp;
}
}
printf("%lld\n", secMST);
return 0;
}
