UVA1151 Buy Or Build 解题报告

UVA1151 Buy Or Build 解题报告

题目链接

https://vjudge.net/problem/UVA-1151

题目大意

平面上有n个点（1≤n≤1000），你的任务是让所有n个点连通。为此，你可以新建一些边，费用等于两个端点的欧几里德距离。另外还有q（0≤q≤8）个“套餐”可以购买，如果你购买了第i个套餐，该套餐中的所有结点将变得相互连通。第i个套餐的花费为Ci。

解题思路

最容易想到的朴素办法是先枚举购买哪些套餐，把套餐中的边权值都设为0，然后再求最小生成树。枚举量为O(2^{q)，给边排序的时间复杂度为O(n}2logn)，Kruskal算法过程是O(n^{2)，因此总复杂度为O(2}q(n^2logn + n^2))，显然会超时。

优化的办法非常简单，考虑到我们选择了套餐相当于把套餐中的边权值设为0，那么选择套餐前的原图Kruskal中未选择的边，在选择了套餐之后一样不会被考虑，所以我们其实可以先在原图上跑一遍Kruskal得到n-1条边，在每次枚举选择了一个套餐后，再到这个新图上求最小生成树，只考虑套餐上的边和这n-1条边，计算量已经被大幅减少了，足以通过本题。复杂度为O(2^q(nlogn + n))。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define endl '\n';
const int maxn = 1e3 + 10;
const int maxm = 1e6 + 10;
const int INF = 0x3fffffff;
const int mod = 1e9 + 7;
struct Edge {
    int u, v, w;
    bool operator < (const Edge &other) const {
        return w < other.w;
    }
} oriEdge[maxm];
vector<int> tc[10];
int tcCost[10];
int x[maxn], y[maxn];
vector<int> newEdge;
int fa[maxn];
int n, m, q;

int getDis(int u, int v) {
    return (x[u] - x[v]) * (x[u] - x[v]) + (y[u] - y[v]) * (y[u] - y[v]);
}

void initDsu() {
    for (int i = 0; i <= n; i++) {
        fa[i] = i;
    }
}

int findRoot(int x) {
    if (x == fa[x])
        return x;
    else
        return findRoot(fa[x]);
}

ll kruskalOri() {
    sort(oriEdge, oriEdge + m);
    ll res = 0;
    for (int i = 0; i < m; i++) {
        int u = oriEdge[i].u;
        int v = oriEdge[i].v;
        int w = oriEdge[i].w;
        int faU = findRoot(u);
        int faV = findRoot(v);
        if (faU != faV) {
            fa[faU] = faV;
            res += w;
            newEdge.push_back(i);
            if (newEdge.size() == n - 1) {
                break;
            }
        }
    }
    return res;
}

ll kruskalNew(int edgeCnt) {
    ll res = 0;
    for (int i = 0; i < newEdge.size(); i++) {
        int j = newEdge[i];
        int u = oriEdge[j].u;
        int v = oriEdge[j].v;
        int w = oriEdge[j].w;
        int faU = findRoot(u);
        int faV = findRoot(v);
        if (faU != faV) {
            fa[faU] = faV;
            res += w;
            edgeCnt++;
            if (edgeCnt == n - 1) {
                break;
            }
        }
    }
    return res;
}

void solve() {
    cin >> n >> q;
    for (int i = 0; i < q; i++) {
        tc[i].clear();
    }
    m = 0;
    initDsu();
    newEdge.clear();

    for (int i = 0; i < q; i++) {
        int num, cost;
        cin >> num >> cost;
        tcCost[i] = cost;
        while (num--) {
            int x;
            cin >> x;
            tc[i].push_back(x);
        }
    }
    for (int i = 1; i <= n; i++) {
        cin >> x[i] >> y[i];
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int w = getDis(i, j);
            oriEdge[m++] = {i, j, w};
        }
    }

    ll ans = kruskalOri();
    for (int i = 0; i < (1 << q); i++) {
        ll ans2 = 0;
        initDsu();
        int edgeCnt = 0;
        for (int j = 0; j < q; j++) {
            if ((i >> j) & 1) {
                ans2 += tcCost[j];
                for (int k = 1; k < tc[j].size(); k++) {
                    int u = tc[j][k - 1];
                    int v = tc[j][k];
                    int faU = findRoot(u);
                    int faV = findRoot(v);
                    if (faU != faV) {
                        fa[faU] = faV;
                        edgeCnt++;
                    }
                }
            }
        }
        ans2 += kruskalNew(edgeCnt);
        ans = min(ans, ans2);
    }
    cout << ans << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout << fixed;
    cout.precision(18);

    int Case = 1;
    cin >> Case;
    while (Case--) {
        solve();
        if (Case)
            cout << "\n";
    }
    return 0;
}