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 + 5;
const int M = 3e5 + 5;
const int K = 25;
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 << 1];
 
int first[N], tot;
 
struct tree_node {
    int fa, dep, mn;
    ll v, sum;
} tr[N];
 
int n, m, k, S, top;
int fa[2][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 + 1, 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 = 0, i = 1; i <= k + 1; ++i) {
        p = root[i];
        fa[0][p] = p;
        first[p] = tr[p].fa = 0, tr[p].mn = inf;
    }
    for (i = 1; i <= k; ++i)
        if (u[i]) {
            x = find(Ek[i].x, 0), y = find(Ek[i].y, 0);
            if (x == y) return 0;
            fa[0][x] = y;
            Add_Edges(Ek[i].x, Ek[i].y);
        }
    for (i = 1; i <= k; ++i) {
        x = find(s[i].x, 0), y = find(s[i].y, 0);
        if (x != y) fa[0][x] = y, Add_Edges(s[i].x, s[i].y);
    }
    dp(S);
    for (i = 1; 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 = 0, i = 1; 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 + 1) {
        ans = max(ans, work());
        return;
    }
    u[p] = 0, dfs(p + 1);
    u[p] = 1, dfs(p + 1);
}
 
int main() {
    int i, x, y;
    n = read(), m = read(), k = read();
    for (i = 1; i <= m; ++i) E[i].get(1);
    for (i = 1; i <= k; ++i) Ek[i].get(0);
    for (i = 1; i <= n; ++i) tr[i].v = read();
    sort(E + 1, E + m + 1);
    for (i = 1; i <= n; ++i) fa[0][i] = fa[1][i] = i;
 
    for (i = 1; i <= k; ++i)
        fa[0][find(Ek[i].x, 0)] = find(Ek[i].y, 0);
#define x E[i].x
#define y E[i].y
    for (i = 1; i <= m; ++i)
        if (find(x, 0) != find(y, 0))
            fa[0][find(x, 0)] = fa[0][find(y, 0)], fa[1][find(x, 1)] = fa[1][find(y, 1)];
#undef x
#undef y
    S = find(1, 1);
    for (i = 1; i <= n; ++i)
        if (find(i, 1) != i) tr[find(i, 1)].v += tr[i].v;
        else root[++cnt_root] = i;
#define x Ek[i].x
#define y Ek[i].y
    for (i = 1; i <= k; ++i)
        x = find(x, 1), y = find(y, 1);
#undef x
#undef y
#define x E[i].x
#define y E[i].y
    for (i = 1; i <= m; ++i)
        x = find(x, 1), y = find(y, 1);
    for (i = 1; i <= m; ++i)
        if (find(x, 1) != find(y, 1))
            s[++top] = E[i], fa[1][find(x, 1)] = find(y, 1);
#undef x
#undef y
    dfs(1);
    printf("%lld
", ans);
    return 0;
}
 
inline int read() {
    static int x;
    static char ch;
    x = 0, ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}