1977: [BeiJing2010组队]次小生成树 Tree

1977: [BeiJing2010组队]次小生成树 Tree

https://lydsy.com/JudgeOnline/problem.php?id=1977

题意：

　　求严格次小生成树，即边权和不能等于最小生成树。

分析：

　　倍增：求出最小生成树，然后枚举非树边，加入一条非树边，删掉环上的最大的边，如果最大的边等于加入的边，那么删掉环上次小的边。

　　LCT：直接维护链上最大值，与次大值。

代码：

倍增

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 inline int read() {
     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
 }

 const int N = ;
 const int M = ;
 const LL INF = 1e18;

 struct Edge{
     int u,v,w;
     bool operator < (const Edge &A) const {
         return w < A.w;
     }
 }e[M];
 int head[N],nxt[N<<],to[N<<],Enum;
 int fa[N],deth[N],f[N][];
 LL g1[N][],g2[N][],val[N<<],Sum;
 bool used[M]; //------ used[N]

 inline void add_edge(int u,int v,int w) {
     ++Enum; to[Enum] = v; val[Enum] = w; nxt[Enum] = head[u]; head[u] = Enum;
     ++Enum; to[Enum] = u; val[Enum] = w; nxt[Enum] = head[v]; head[v] = Enum;
 }
 void dfs(int u,int fa) {
     deth[u] = deth[fa] + ;
     for (int i=head[u]; i; i=nxt[i]) {
         int v = to[i];
         if (v == fa) continue; // 写在下面了。。。
         f[v][] = u;
         g1[v][] = val[i]; // -- e[i].w
         g2[v][] = -INF;
         dfs(v,u);
     }
 }
 inline void get(LL a,LL b,LL &mx1,LL &mx2) {
     if (a > mx1) mx2 = max(mx1,b);
     else if (a == mx1) mx2 = max(mx2, b);
     else if (a < mx1) mx2 = max(mx2, a);
     mx1 = max(mx1,a);
 }
 inline LL solve(int u,int v,int w) {
     if (deth[u] < deth[v]) swap(u,v);
     int d = deth[u] - deth[v];
     LL mx1 = -INF, mx2 = -INF;
     for (int i=; i>=; --i) {
         if (d & ( << i)) {
             get(g1[u][i],g2[u][i],mx1,mx2);
             u = f[u][i];
         }
     }
     if (u == v) return Sum + w - (mx1 < w ? mx1 : mx2);
     for (int i=; i>=; --i) {
         if (f[u][i] != f[v][i]) { // -- f[u][i]==f[u][i]
             get(g1[u][i],g2[u][i],mx1,mx2);
             get(g1[v][i],g2[v][i],mx1,mx2);
             u = f[u][i], v = f[v][i];
         }
     }
     get(g1[u][],g2[u][],mx1,mx2);
     get(g1[v][],g2[v][],mx1,mx2);
     return Sum + w - (mx1 < w ? mx1 : mx2);
 }
 int find(int x) {
     return x == fa[x] ? x : fa[x] = find(fa[x]);
 }
 int main() {

     int n = read(),m = read();
     for (int i=; i<=m; ++i) {
         e[i].u = read(), e[i].v = read(), e[i].w = read();
     }
     sort(e+,e+m+);
     for (int i=; i<=n; ++i) fa[i] = i;
     int cnt = ;
     for (int i=; i<=m; ++i) {
         int u = find(e[i].u), v = find(e[i].v);
         if (u != v) {
             used[i] = true;
             add_edge(e[i].u,e[i].v,e[i].w);
             fa[u] = v;
             Sum += e[i].w;
             cnt++;
             if (cnt == n-) break;
         }
     }
     dfs(,);
     for (int j=; j<=; ++j)
         for (int i=; i<=n; ++i) {
             int k = f[i][j-];
             LL a1 = g1[i][j-], a2 = g1[k][j-];
             LL b1 = g2[i][j-], b2 = g2[k][j-];
             f[i][j] = f[k][j-];
             g1[i][j] = max(a1, a2);
             if (a1 == a2) g2[i][j] = max(b1, b2);
             else {
                 g2[i][j] = min(a1, a2);
                    g2[i][j] = max(g2[i][j], max(b1, b2)); //---
             }
         }
     LL Ans = INF; // -- ANs = Sum
     for (int i=; i<=m; ++i) {
         if (!used[i])
             Ans = min(Ans, solve(e[i].u,e[i].v,e[i].w));
     }
     cout << Ans;
     return ;
 }

LCT

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;

 inline int read() {
     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
 }

 const int N = ;
 const int M = ;

 struct Edge{
     int u,v,w;
     bool operator < (const Edge &A) const {
         return w < A.w;
     }
 }e[M];
 int fa[N<<],ch[N<<][],fir[N<<],sec[N<<],rev[N<<],sk[N<<],Top;
 LL val[N<<];
 int p[N];

 bool isroot(int x) {
     return ch[fa[x]][] != x && ch[fa[x]][] != x;
 }
 int son(int x) {
     return ch[fa[x]][] == x;
 }
 void pushup(int x) {
     int lc = ch[x][], rc = ch[x][];
     if (fir[lc] > fir[rc]) fir[x] = fir[lc], sec[x] = max(sec[lc], fir[rc]);
     else if (fir[lc] < fir[rc]) fir[x] = fir[rc], sec[x] = max(sec[rc], fir[lc]);
     else fir[x] = fir[lc], sec[x] = max(sec[lc], sec[rc]);

     if (val[x] > fir[x]) sec[x] = fir[x], fir[x] = val[x];
     else if (val[x] < fir[x] && val[x] > sec[x]) sec[x] = val[x];
 }
 void pushdown(int x) {
     if (rev[x]) {
         rev[ch[x][]] ^= , rev[ch[x][]] ^= ;
         swap(ch[x][], ch[x][]);
         rev[x] ^= ;
     }
 }
 void rotate(int x) {
     int y = fa[x],z = fa[y],b = son(x),c = son(y),a = ch[x][!b];
     if (!isroot(y)) ch[z][c] = x; fa[x] = z;
     ch[x][!b] = y;fa[y] = x;
     ch[y][b] = a; if (a) fa[a] = y;
     pushup(y); pushup(x);
 }
 void splay(int x) {
     sk[Top = ] = x;
     for (int i=x; !isroot(i); i=fa[i]) sk[++Top] = fa[i];
     while (Top) pushdown(sk[Top--]);
     while (!isroot(x)) {
         int y = fa[x];
         if (isroot(y)) rotate(x);
         else {
             if (son(x) == son(y)) rotate(y), rotate(x);
             else rotate(x), rotate(x);
         }
     }
 }
 void access(int x) {
     for (int last=; x; last=x,x=fa[x]) {
         splay(x); ch[x][] = last; pushup(x);
     }
 }
 void makeroot(int x) {
     access(x); splay(x); rev[x] ^= ;
 }
 int find(int x) {
     return x == p[x] ? x : p[x] = find(p[x]);
 }

 int main() {
     int n = read(),m = read(),Index = n;
     for (int i=; i<=n; ++i) p[i] = i;
     for (int i=; i<=m; ++i) {
         e[i].u = read(), e[i].v = read(), e[i].w = read();
     }
     sort(e+,e+m+);
     LL Sum = , Ans = 1e18;
     for (int i=; i<=m; ++i) {
         int x = e[i].u, y = e[i].v;
         int u = find(x), v = find(y);
         if (u != v) {
             makeroot(x);
             fa[x] = ++Index; // 化边权为点权
             fa[Index] = y;
             fir[Index] = val[Index] = e[i].w;
             Sum += e[i].w;
             p[u] = v;
         }
         else {
             makeroot(x);
             access(y);
             splay(y);
             Ans = min(Ans, (LL)e[i].w - (e[i].w > fir[y] ? fir[y] : sec[y]));
         }
     }
     cout << Ans + Sum;
     return ;
 }

upd：2018.10.22

前几天模拟赛出了这道题，考试的时候写的，感觉比以前的好写些。

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<iostream>
 #include<cctype>
 #include<set>
 #include<vector>
 #include<queue>
 #include<map>
 #define fi(s) freopen(s,"r",stdin);
 #define fo(s) freopen(s,"w",stdout);
 using namespace std;
 typedef long long LL;

 char buf[], *p1 = buf, *p2 = buf;
 #define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
 inline int read() {
     int x=,f=;char ch=nc();for(;!isdigit(ch);ch=nc())if(ch=='-')f=-;
     for(;isdigit(ch);ch=nc())x=x*+ch-'';return x*f;
 }

 const int N = ;
 const int LOG = ;

 struct Edge{
     int u, v; LL w;
     bool operator < (const Edge &A) const {
         return w < A.w;
     }
 }e[N * ], R[N * ];

 struct ST{
     int x;LL mx, ci;
     ST() { x = mx = ci = ; }
 }f[N][];
 int head[N], to[N * ], nxt[N * ]; LL len[N * ];
 int fa[N], deth[N];
 int n, m, En, tot; LL Sum;

 ST operator + (const ST &A, const ST &B) {
     ST res; res.x = B.x;
     if (A.mx > B.mx) res.mx = A.mx, res.ci = max(A.ci, B.mx);
     else if (B.mx > A.mx) res.mx = B.mx, res.ci = max(A.mx, B.ci);
     else res.mx = A.mx, res.ci = max(A.ci, B.ci);
     return res;
 }

 inline void add_edge(int u,int v,LL w) {
     ++En; to[En] = v; len[En] = w; nxt[En] = head[u]; head[u] = En;
     ++En; to[En] = u; len[En] = w; nxt[En] = head[v]; head[v] = En;
 }
 int find(int x) {
     return x == fa[x] ? x : fa[x] = find(fa[x]);
 }
 void Kruskal() {
     sort(e + , e + m + );
     for (int i=; i<=n; ++i) fa[i] = i;
     for (int i=; i<=m; ++i) {
         int u = find(e[i].u), v = find(e[i].v);
         if (u != v) {
             fa[u] = v; Sum += e[i].w;
             add_edge(e[i].u, e[i].v, e[i].w);
         }
         else R[++tot] = e[i];
     }
 }

 void dfs(int u,int pa) {
     deth[u] = deth[pa] + ;
     for (int i=head[u]; i; i=nxt[i]) {
         int v = to[i];
         if (v == pa) continue;
         dfs(v, u);
         f[v][].x = u;
         f[v][].mx = len[i];
     }
 }

 void D(const ST &A) {
     cerr << A.x << " " << A.mx << " " << A.ci << "\n";
 }

 ST work(int u,int v) {
     ST ans; //ans.mx = -1; ans.ci = -1; ans.x = 0;
     if (deth[u] < deth[v]) swap(u, v);
     int d = deth[u] - deth[v];
     for (int j=LOG; j>=; --j) {
         if ((d >> j) & ) {
             ans = ans + f[u][j]; // 顺序！！！
             u = f[u][j].x;
 //            D(ans);
         }
     }
     if (u == v) return ans;
     for (int j=LOG; j>=; --j) {
         if (f[u][j].x != f[v][j].x) {
             ans = ans + f[u][j]; ans = ans + f[v][j];
             u = f[u][j].x, v = f[v][j].x;
 //            D(ans);
         }
     }
     return ans + f[u][] + f[v][];
 }

 int main() { //fi("2.txt");

 //    freopen("tree.in","r",stdin);
 //    freopen("tree.out","w",stdout);

     n = read(), m = read();
     for (int i=; i<=m; ++i)
         e[i].u = read(), e[i].v = read(), e[i].w = read();
     sort(e + , e + m + );
     Kruskal();
     dfs(, );

     for (int j=; j<=LOG; ++j)
         for (int i=; i<=n; ++i)
             f[i][j] = f[i][j - ] + f[f[i][j - ].x][j - ];

     ST now;
     LL Ans = 1e18;
     for (int i=; i<=tot; ++i) {
         now = work(R[i].u, R[i].v);
         if (R[i].w != now.mx) Ans = min(Ans, Sum - now.mx + R[i].w);
         else if (now.ci) Ans = min(Ans, Sum - now.ci + R[i].w);
     }
     cout << Ans;
     return ;
 }