BZOJ1937 [Shoi2004]Mst 最小生成树

首先由贪心的想法知道，树边只减不加，非树边只加不减，令$w_i$表示i号边原来的边权，$d_i$表示i号边的改变量

对于一条非树边$j$连接着两个点$x$、$y$，则对于$xy$这条路径上的所有树边$i$，都要满足：$w_i - d_i \le w_j + d_j$

移项可得$w_i -w_j \le d_i + d_j$

于是我们发现$d[]$就是KM算法里的顶标了，直接跑最大匹配即可

 /**************************************************************
     Problem: 1937
     User: rausen
     Language: C++
     Result: Accepted
     Time:700 ms
     Memory:4796 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 using namespace std;
 const int N = ;
 const int M = ;
 const int inf = 1e9;

 inline int read();

 struct edge {
     int next, to, id;
     edge(int _n = , int _t = , int _i = ) : next(_n), to(_t), id(_i) {}
 } e[N << ];

 struct Edge {
     int x, y, v, f;

     inline void get() {
         x = read(), y = read(), v = read(), f = ;
     }
 } E[M];

 struct tree_node {
     int dep, fa[], e;
 } tr[N];

 int n, m;
 int first[N], tot;
 int mp[M][M];

 namespace KM {
     int slack[M], lx[M], ly[M], linky[M];
     bool visx[M], visy[M];

     bool find(int x) {
         int y, tmp;
         for (visx[x] = y = ; y <= m; ++y) if (!visy[y]) {
                 tmp = lx[x] + ly[y] - mp[x][y];
                 if (tmp == ) {
                     visy[y] = ;
                     if (linky[y] == - || find(linky[y])) {
                         linky[y] = x;
                         return ;
                     }
                 } else
                 if (slack[y] > tmp) slack[y] = tmp;
             }
         return ;
     }

     int work() {
         static int i, j, x, d, res;
         memset(linky, -, sizeof(linky));
         memset(ly, , sizeof(ly));
         for (i = ; i <= m; ++i)
             for (j = , lx[i] = -inf; j <= m; ++j)
                 lx[i] = max(lx[i], mp[i][j]);
         for (x = ; x <= m; ++x) {
             for (i = ; i <= m; ++i)
                 slack[i] = inf;
             while() {
                 memset(visx, , sizeof(visx));
                 memset(visy, , sizeof(visy));
                 if (find(x)) break;
                 d = inf;
                 for (i = ; i <= m; ++i)
                     if (!visy[i]) d = min(d, slack[i]);
                 for (i = ; i <= m; ++i)
                     if (visx[i]) lx[i] -= d;
                 for (i = ; i <= m; ++i)
                     if (visy[i]) ly[i] += d;
                     else slack[i] -= d;
             }
         }
         for (res = , i = ; i <= m; ++i)
             res += mp[linky[i]][i];
         return res;
     }
 };

 inline void Add_Edges(int x, int y, int id) {
     e[++tot] = edge(first[x], y, id), first[x] = tot;
     e[++tot] = edge(first[y], x, id), first[y] = tot;
 }

 #define y e[x].to
 inline void dfs(int p) {
     int i, x;
     tr[p].dep = tr[tr[p].fa[]].dep + ;
     for (i = ; i <= ; ++i)
         tr[p].fa[i] = tr[tr[p].fa[i - ]].fa[i - ];
     for (x = first[p]; x; x = e[x].next)
         if (y != tr[p].fa[]) {
             tr[y].fa[] = p, tr[y].e = e[x].id;
             dfs(y);
         }
 }
 #undef y

 inline int lca(int x, int y) {
     static int i;
     if (tr[x].dep < tr[y].dep) swap(x, y);
     for (i = ; ~i; --i)
         if (tr[tr[x].fa[i]].dep >= tr[y].dep) x = tr[x].fa[i];
     if (x == y) return x;
     for (i = ; ~i; --i)
         if (tr[x].fa[i] != tr[y].fa[i])
             x = tr[x].fa[i], y = tr[y].fa[i];
     return tr[x].fa[];
 }

 inline void build(int x, int f, int e, int v) {
     while (x != f)
         mp[tr[x].e][e] = max(, E[tr[x].e].v - v), x = tr[x].fa[];
 }

 int main() {
     int i, j;
     int x, y, f;
     n = read(), m = read();
     for (i = ; i <= m; ++i)
         E[i].get();
     for (i = ; i < n; ++i) {
         x = read(), y = read();
         for (j = ; j <= m; ++j)
             if ((E[j].x == x && E[j].y == y) || (E[j].x == y && E[j].y == x)) {
                 E[j].f = ;
                 Add_Edges(x, y, j);
                 break;
             }
     }
     dfs();
     for (i = ; i <= m; ++i)
         if (!E[i].f) {
             x = E[i].x, y = E[i].y, f = lca(x, y);
             build(x, f, i, E[i].v);
             build(y, f, i, E[i].v);
         }
     printf("%d\n", KM::work());
     return ;
 }

 inline int read() {
     static int x;
     static char ch;
     x = , ch = getchar();
     while (ch < '' || '' < ch)
         ch = getchar();
     while ('' <= ch && ch <= '') {
         x = x *  + ch - '';
         ch = getchar();
     }
     return x;
 }