（最大k度限制生成树）POJ 1639

题意：

给一个无向带权图，图上有不超过20个人和1个公园，现在这些人想到公园去集合，他们可以直接去公园也可以，和其他人一起坐车去公园（假设他们的车容量无限），但是这个公园停车场只有k个位置，现在要求他们到达公园所需要的总花费。

---

分析：

乍一看是最小生成树，但是停车场只有k个位置，所以就限定了公园节点只能最多连k个人，也就是说有一个点的度数是给定了的。

想了很久，第一感觉就是想其他生成树那样，肯定要把边删去，从环中选择更优解， 按套路来说。

但是想了很久不知道怎么处理。

不过，看到题目只有20个人，k<20，可以从n个人中选出k个人，与停车场连接，然后跑最小生成树。虽然很暴力，但最大复杂度才C(20,10)*mlogm，看起来不是很大啊，也的的确确A了，但是跑了接近2s，显然POJ数据真的很水。

其实这题是经典的问题，国家队论文里有讲，据说刘汝佳黑书里也有。推荐一个不错的博客：http://blog.csdn.net/nacl__/article/details/52052133

没错，我就是抄他代码的，自己写半天感觉非常搓，不过，他的代码没有删边，

这句话有问题，我修改了一下。

最近看了一下生成树和最短路的题，感觉天天发现新大陆啊。

---

代码：

标程

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
// #include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;

#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-9)
#define fi first
#define se second

bool sgn(double a, string select, double b) {
    if(select == "==")return fabs(a - b) < eps;
    if(select == "!=")return fabs(a - b) > eps;
    if(select == "<")return a - b < -eps;
    if(select == "<=")return a - b < eps;
    if(select == ">")return a - b > eps;
    if(select == ">=")return a - b > -eps;
}


//--------------------------

const ll mod = 1000000007;
const int maxn = 30;

struct Edge {
    int u, v, d;
    Edge() {}
    Edge(int a, int b, int c): u(a), v(b), d(c) {}
    bool operator<(const Edge &e)const {
        return d < e.d;
    }
};

int n, m, k;
int cnt;
int ans;
int parent[maxn];
map<string, int> nodes;
vector<Edge>edges;
int g[maxn][maxn];
bool tree[maxn][maxn];
int minEdge[maxn];
Edge dp[maxn];

int find(int p) {
    if(p == parent[p])return p;
    else return parent[p] = find(parent[p]);
}

void un(int p, int q) {
    parent[find(p)] = find(q);
}

void Kruskal() {
    sort(edges.begin(), edges.end());
    for(int i = 0; i < edges.size(); i++) {
        int p = edges[i].u;
        int q = edges[i].v;
        if(p == 1 || q == 1)continue;
        if(find(p) != find(q)) {
            un(p, q);
            tree[p][q] = tree[q][p] = 1;
            ans += edges[i].d;
        }
    }
}

void dfs(int cur, int pre) {
    for(int i = 2; i <= cnt; i++) {
        if(i == pre || !tree[cur][i])continue;
        if(dp[i].d == -1) {
            if(dp[cur].d > g[cur][i])dp[i] = dp[cur];
            else {
                dp[i].u = cur;
                dp[i].v = i;
                dp[i].d = g[cur][i];
            }
        }
        dfs(i, cur);
    }
}


void init() {
    memset(g, inf, sizeof(g));
    memset(tree, 0, sizeof(tree));
    memset(minEdge, inf, sizeof(minEdge));
    m = 0;
    cnt = 1;
    ans = 0;
    nodes["Park"] = 1;
    for(int i = 0; i < maxn; i++) {
        parent[i] = i;
    }
}

void solve() {
    scanf("%d", &n);
    string s1, s2;
    int d;
    init();
    for(int i = 1; i <= n; i++) {
        cin >> s1 >> s2 >> d;
        if(!nodes[s1])nodes[s1] = ++cnt;
        if(!nodes[s2])nodes[s2] = ++cnt;
        int u = nodes[s1];
        int v = nodes[s2];
        edges.push_back(Edge(u, v, d));
        g[u][v] = g[v][u] = min(g[u][v], d);
    }
    scanf("%d", &k);
    Kruskal();
    int keyPoint[maxn];
    for(int i = 2; i <= cnt; i++) {
        if(g[1][i] != inf) {
            int color = find(i);
            if(minEdge[color] > g[1][i]) {
                minEdge[color] = g[1][i];
                keyPoint[color] = i;

            }
        }
    }
    for(int i = 1; i <= cnt; i++) {
        if(minEdge[i] != inf) {
            m++;
            tree[1][keyPoint[i]] = tree[keyPoint[i]][1] = 1;
            ans += g[1][keyPoint[i]];
        }
    }
    for(int i = m + 1; i <= k; i++) {
        memset(dp, -1, sizeof(dp));
        dp[1].d = -inf;
        for(int j = 2; j <= cnt; j++)
            if(tree[1][j])
                dp[j].d = -inf;
        dfs(1, -1);
        int idx, minnum = inf;
        for(int j = 2; j <= cnt; j++) {
            if(minnum > g[1][j] - dp[j].d) {
                minnum = g[1][j] - dp[j].d;
                idx = j;
            }
        }
        if(minnum >= 0)
            break;
        tree[1][idx] = tree[idx][1] = 1;
        tree[dp[idx].u][dp[idx].v] = tree[dp[idx].v][dp[idx].u] = 0;
        ans += minnum;
    }
    printf("Total miles driven: %d
", ans);
}

int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    // freopen("1.out", "w", stdout);
#endif
    // iostream::sync_with_stdio(false);
    solve();
    return 0;
}

暴力

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
// #include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;

#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-9)
#define fi first
#define se second

bool sgn(double a, string select, double b) {
    if(select == "==")return fabs(a - b) < eps;
    if(select == "!=")return fabs(a - b) > eps;
    if(select == "<")return a - b < -eps;
    if(select == "<=")return a - b < eps;
    if(select == ">")return a - b > eps;
    if(select == ">=")return a - b > -eps;
}


//--------------------------

const ll mod = 1000000007;
const int maxn = 100010;

int n, k;

map<string, int> name;
int cnt;
int edn;
int pkn;

struct Edge {
    int u, v, c;
};

bool cmp(Edge a, Edge b ) {
    return a.c < b.c;
}


Edge raw_edges[500];
Edge park_edges[500];
Edge edges[500];

string a, b;
int x;

int ans = inf;

int max_park;

int par[500];
int findx(int x) {
    if(par[x] == x)return x;
    else return par[x] = findx(par[x]);
}


int Kruskal(int n) {
    int m = edn + max_park;
    for(int i = 0; i < n; i++) {
        par[i] = i;
    }
    sort(edges, edges + m , cmp);
    int cnt = 0;
    int ans = 0;
    for(int i = 0; i < m; i++) {
        int u = edges[i].u;
        int v = edges[i].v;
        int c = edges[i].c;
        int t1 = findx(u);
        int t2 = findx(v);
        if(t1 != t2) {
            ans += c;
            par[t1] = t2;
            cnt++;
        }
        if(cnt == n - 1)break;
    }
    if(cnt < n - 1)return -1;
    else return ans;
}


int select[30];

void dfs(int now, int pre) {
    if(now >= max_park) {
        for(int i = 0; i < edn; i++) {
            edges[i] = raw_edges[i];
        }
        int con = edn;
        for(int i = 0; i < now; i++) {
            edges[con++] = park_edges[select[i]];
        }
        int mins = Kruskal(cnt);
        // for(int i = edn; i < con; i++) {
        //     printf("%d %d
", edges[i].u, edges[i].v );
        // }
        // printf("res = %d
", mins );
        if(mins != -1) {
            ans = min(ans, mins);
        }
        return ;
    }
    for(int i = pre + 1; i < pkn; i++) {
        select[now] = i;
        dfs(now + 1, i);
    }

}


void solve() {
    while(cin >> n) {
        cnt = edn = pkn = 0;
        ans = inf;
        name.clear();
        for(int i = 0; i < n; i++) {
            cin >> a >> b >> x;
            if(name.find(a) == name.end()) {
                name[a] = cnt++;
            }
            if(name.find(b) == name.end()) {
                name[b] = cnt++;
            }
            if(a == "Park" || b == "Park") {
                park_edges[pkn++] = Edge{name[a], name[b], x};
            } else {
                raw_edges[edn++] = Edge{name[a], name[b], x};
            }
        }
        scanf("%d", &k);
        max_park = min(pkn, k);
        dfs(0, -1);
        printf("Total miles driven: %d
", ans);
    }


}

int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
#endif
    // iostream::sync_with_stdio(false);
    solve();
    return 0;
}