BZOJ3206 [Apio2013]道路费用

首先我们强制要求几条待定价的边在MST中，建出MST

我们发现这个MST中原来的边是一定要被选上的，所以可以把点缩起来，搞成一棵只有$K$个点的树

然后$2^K$枚举每条边在不在最终的MST中，让在最终MST中的待定价的边尽量大，只需要在Kruskal的时候暴力更新每条边的定价即可

时间复杂度$O(m * logm + 2^K * K^2)$

 /**************************************************************
     Problem: 3206
     User: rausen
     Language: C++
     Result: Accepted
     Time:8040 ms
     Memory:8232 kb
 ****************************************************************/

 #include <cstdio>
 #include <algorithm>

 using namespace std;
 typedef long long ll;
 const int N = 1e5 + ;
 const int M = 3e5 + ;
 const int K = ;
 const int inf = 1e9;

 inline int read();

 struct Edge {
     int x, y, v;

     inline void get(int f) {
         x = read(), y = read();
         if (f) v = read();
     }

     inline bool operator < (const Edge &E) const {
         return v < E.v;
     }
 } E[M], Ek[K], s[K];

 struct edge {
     int next, to;
     edge() {}
     edge(int _n, int _t) : next(_n), to(_t) {}
 } e[K << ];

 int first[N], tot;

 struct tree_node {
     int fa, dep, mn;
     ll v, sum;
 } tr[N];

 int n, m, k, S, top;
 int fa[][N];
 int root[K], cnt_root;
 int u[K];
 ll ans;

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

 int find(int x, int f) {
     return x == fa[f][x] ? x : fa[f][x] = find(fa[f][x], f);
 }

 #define y e[x].to
 void dp(int p) {
     int x;
     tr[p].sum = tr[p].v;
     for (x = first[p]; x; x = e[x].next)
         if (y != tr[p].fa) {
             tr[y].dep = tr[p].dep + , tr[y].fa = p;
             dp(y);
             tr[p].sum += tr[y].sum;
         }
 }
 #undef y

 ll work() {
     static int i, x, y, p;
     static ll res;
     for (tot = , i = ; i <= k + ; ++i) {
         p = root[i];
         fa[][p] = p;
         first[p] = tr[p].fa = , tr[p].mn = inf;
     }
     for (i = ; i <= k; ++i)
         if (u[i]) {
             x = find(Ek[i].x, ), y = find(Ek[i].y, );
             if (x == y) return ;
             fa[][x] = y;
             Add_Edges(Ek[i].x, Ek[i].y);
         }
     for (i = ; i <= k; ++i) {
         x = find(s[i].x, ), y = find(s[i].y, );
         if (x != y) fa[][x] = y, Add_Edges(s[i].x, s[i].y);
     }
     dp(S);
     for (i = ; i <= k; ++i) {
         x = s[i].x, y = s[i].y;
         if (tr[x].dep < tr[y].dep) swap(x, y);
         while (tr[x].dep != tr[y].dep)
             tr[x].mn = min(tr[x].mn, s[i].v), x = tr[x].fa;
         while (x != y) {
             tr[x].mn = min(tr[x].mn, s[i].v);
             tr[y].mn = min(tr[y].mn, s[i].v);
             x = tr[x].fa, y = tr[y].fa;
         }
     }
 #define x Ek[i].x
 #define y Ek[i].y
     for (res = , i = ; i <= k; ++i)
         if (u[i])
             res += tr[x].dep > tr[y].dep ? tr[x].mn * tr[x].sum : tr[y].mn * tr[y].sum;
 #undef x
 #undef y
     return res;
 }

 void dfs(int p) {
     if (p == k + ) {
         ans = max(ans, work());
         return;
     }
     u[p] = , dfs(p + );
     u[p] = , dfs(p + );
 }

 int main() {
     int i, x, y;
     n = read(), m = read(), k = read();
     for (i = ; i <= m; ++i) E[i].get();
     for (i = ; i <= k; ++i) Ek[i].get();
     for (i = ; i <= n; ++i) tr[i].v = read();
     sort(E + , E + m + );
     for (i = ; i <= n; ++i) fa[][i] = fa[][i] = i;

     for (i = ; i <= k; ++i)
         fa[][find(Ek[i].x, )] = find(Ek[i].y, );
 #define x E[i].x
 #define y E[i].y
     for (i = ; i <= m; ++i)
         if (find(x, ) != find(y, ))
             fa[][find(x, )] = fa[][find(y, )], fa[][find(x, )] = fa[][find(y, )];
 #undef x
 #undef y
     S = find(, );
     for (i = ; i <= n; ++i)
         if (find(i, ) != i) tr[find(i, )].v += tr[i].v;
         else root[++cnt_root] = i;
 #define x Ek[i].x
 #define y Ek[i].y
     for (i = ; i <= k; ++i)
         x = find(x, ), y = find(y, );
 #undef x
 #undef y
 #define x E[i].x
 #define y E[i].y
     for (i = ; i <= m; ++i)
         x = find(x, ), y = find(y, );
     for (i = ; i <= m; ++i)
         if (find(x, ) != find(y, ))
             s[++top] = E[i], fa[][find(x, )] = find(y, );
 #undef x
 #undef y
     dfs();
     printf("%lld\n", ans);
     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;
 }