《挑战程序设计竞赛》2.5 最小生成树 POJ3723 3169 1258 2377 2395 AOJ2224（1）

POJ3723

http://poj.org/problem?id=3723

题意

windy要组建一支军队，召集了N个女孩和M个男孩，每个人要付10000RMB，但是如果一个女孩和一个男孩有关系d的，且已经付给了其中一个人的钱，那么就可以付给另一个人10000-d元，求windy最少要付多少钱。

思路

题目所给的数据是两两之间的连通关系，比较适合用kruskal+并查集求解。

但这个题要求的是最大生成树，不是最小生成树哦，需要修改比较条件。当然将d取反再求最小生成树也是一样的。

代码

Source Code

Problem: 3723       User: liangrx06
Memory: 996K        Time: 360MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 20000;
const int R = 50000;

struct Node {
    int x, y, d;
};

int n, r;
Node node[R+1];
int pre[N+1];
int rank[N+1];

bool cmp(const Node& a, const Node& b)
{
    return a.d < b.d;
}

void init()
{
    for (int i = 1; i <= n; i ++) {
        pre[i] = i;
        rank[i] = 0;
    }
}

int find(int a)
{
    while (a != pre[a])
        a = pre[a];
    return a;
}

void unite(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a == b) return;
    if (rank[a] < rank[b]) {
        pre[a] = b;
    } else {
        pre[b] = a;
        if (rank[a] == rank[b])
            rank[a] ++;
    }
}

bool same(int a, int b)
{
    return find(a) == find(b);
}

int kruskal()
{
    sort(node+1, node+r+1, cmp);
    int res = 0;
    for (int i = 1; i <= r; i ++) {
        int x = node[i].x, y = node[i].y;
        if (!same(x, y)) {
            unite(x, y);
            res += node[i].d;
        }
    }
    return res;
}

int main(void)
{
    int t, n1, n2;
    cin >> t;
    while (t--) {
        cin >> n1 >> n2 >> r;
        n = n1 + n2;
        int x, y, d;
        for (int i = 1; i <= r; i ++) {
            scanf("%d%d%d", &x, &y, &d);
            node[i].x = x + 1;
            node[i].y = n1 + y + 1;
            node[i].d = -d;
        }
        init();
        printf("%d\n", 10000 * n + kruskal());
    } 

    return 0;
}   

POJ3169

POJ1258

http://poj.org/problem?id=1258

题意

有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离。

思路

求最小生成树，由于这个题直接给出了邻接矩阵，所以用prim算法比较合适。

代码

Source Code

Problem: 1258       User: liangrx06
Memory: 212K        Time: 16MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
using namespace std;

const int N = 100;
const int INF = 0x3f3f3f3f;

int n;
int d[N][N];
int md[N];
bool used[N];

int prim()
{
    fill(md, md+n, INF);
    fill(used, used+n, false);
    md[0] = 0;
    int res = 0;
    while (true) {
        int v = -1;
        for (int i = 0; i < n; i ++) {
            if (!used[i] && (v == -1 || md[i] < md[v]))
                v = i;
        }
        if (v == -1) break;
        used[v] = true;
        res += md[v];
        for (int i = 0; i < n; i ++) {
            md[i] = min(md[i], d[v][i]);
        }
    }
    return res;
}

int main(void)
{
    while (scanf("%d", &n) != EOF) {
        for (int i = 0; i < n; i ++) {
            for (int j = 0; j < n; j ++) {
                scanf("%d", &d[i][j]);
            }
        }
        printf("%d\n", prim());
    } 

    return 0;
} 

POJ2377

http://poj.org/problem?id=2377

题意

给定一些两点之间的连通距离，求最大生成树。

思路

题目所给的数据是两两之间的连通关系，比较适合用kruskal+并查集求解。

但这个题要求的是最大生成树，排序的时候按降序排列或者将距离取反最后结果再取反就可以了。

代码

Source Code

Problem: 2377       User: liangrx06
Memory: 496K        Time: 32MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 1000;
const int M = 20000;

struct Node {
    int x, y, d;
};

int n, m;
Node node[M+1];
int pre[N+1];
int rank[N+1];

bool cmp(const Node& a, const Node& b)
{
    return a.d < b.d;
}

void init()
{
    for (int i = 1; i <= n; i ++) {
        pre[i] = i;
        rank[i] = 0;
    }
}

int find(int a)
{
    while (a != pre[a])
        a = pre[a];
    return a;
}

void unite(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a == b) return;
    if (rank[a] < rank[b]) {
        pre[a] = b;
    } else {
        pre[b] = a;
        if (rank[a] == rank[b])
            rank[a] ++;
    }
}

bool same(int a, int b)
{
    return find(a) == find(b);
}

int kruskal()
{
    sort(node+1, node+m+1, cmp);
    int res = 0;
    int uniteTime = 0;
    for (int i = 1; i <= m; i ++) {
        int x = node[i].x, y = node[i].y;
        if (!same(x, y)) {
            unite(x, y);
            uniteTime ++;
            res += node[i].d;
        }
    }
    if (uniteTime == n-1)
        return -res;
    else
        return -1;
}

int main(void)
{
    cin >> n >> m;
    for (int i = 1; i <= m; i ++) {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].d);
        node[i].d *= -1;
    }
    init();
    printf("%d\n", kruskal());

    return 0;
}

POJ2395

http://poj.org/problem?id=2395

题意

有N个农场,它们是连通的，现在你要从1号农场找到路走到其他所有农场去。但是有个要求就是你必须使得你将要走的单段路的最大长度最小。也就是说，任意两个农场之间的路如果被你选中要走的话，那么这种单段路的最大值必须尽量小。

思路

其实就是要你选一些路使得所有农场属于同一个连通分量,且要求你输出最大边的值. 仔细想想kruskal算法,它从所有边长从小到大的顺序开始选边,每次选边都使得两个点连通. 可以证明kruskal算法所选择的最后一条边即是我们本题的答案.

最小瓶颈生成树在刘汝佳<<训练指南>>P343页有详细的介绍.

无向图G的一颗瓶颈生成树(bottleneck spanning tree)T是这样的一颗生成树，它最大的边权值在G的所有生成树中是最小的。

无向图的最小生成树一定是瓶颈生成树，但瓶颈生成树不一定是最小生成树。(来自百度百科:瓶颈生成树)

代码

Source Code

Problem: 2395       User: liangrx06
Memory: 388K        Time: 79MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 2000;
const int M = 10000;

struct Node {
    int x, y, d;
};

int n, m;
Node node[M+1];
int pre[N+1];
int rank[N+1];

bool cmp(const Node& a, const Node& b)
{
    return a.d < b.d;
}

void init()
{
    for (int i = 1; i <= n; i ++) {
        pre[i] = i;
        rank[i] = 0;
    }
}

int find(int a)
{
    while (a != pre[a])
        a = pre[a];
    return a;
}

void unite(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a == b) return;
    if (rank[a] < rank[b]) {
        pre[a] = b;
    } else {
        pre[b] = a;
        if (rank[a] == rank[b])
            rank[a] ++;
    }
}

bool same(int a, int b)
{
    return find(a) == find(b);
}

int kruskal()
{
    sort(node+1, node+m+1, cmp);
    int res = 0;
    int uniteTime = 0;
    for (int i = 1; i <= m; i ++) {
        int x = node[i].x, y = node[i].y;
        if (!same(x, y)) {
            unite(x, y);
            uniteTime ++;
            res = node[i].d;
        }
    }
    if (uniteTime == n-1)
        return res;
    else
        return -1;
}

int main(void)
{
    cin >> n >> m;
    for (int i = 1; i <= m; i ++) {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].d);
    }
    init();
    printf("%d\n", kruskal());

    return 0;
}

AOJ2224

http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2224

题意

有N个木桩M个栅栏，栅栏连接木桩，现在这些栅栏围成的封闭空间里有至少一只猫，要求破环若干个栅栏救出猫，问破环栅栏的最小长度。

思路

题目要求栅栏不组成圈，又要求破坏栅栏的最小长度，那么剩下的栅栏自然是最大生成树了（当然前提是图是连通的）。kruskal+并查集求最大生成树，在从大到小添加边的过程中，如果发现新添加的边的两个节点已经连通，说明这个边需要去掉，累加这个边的长度到结果变量res。
另外，即使这个图非连通，这样的破圈求解过程仍然能够得到正确答案。

代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;

const int N = 10000;
const int M = 10000*10000/2;

struct Node {
    int x, y;
    double d;
};

int n, m;
Node node[M+1];
int pre[N+1];
int rank[N+1];

bool cmp(const Node& a, const Node& b)
{
    return a.d > b.d;
}

void init()
{
    for (int i = 1; i <= n; i ++) {
        pre[i] = i;
        rank[i] = 0;
    }
}

int find(int a)
{
    while (a != pre[a])
        a = pre[a];
    return a;
}
void unite(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a == b) return;
    if (rank[a] < rank[b]) {
        pre[a] = b;
    } else {
        pre[b] = a;
        if (rank[a] == rank[b])
            rank[a] ++;
    }
}

bool same(int a, int b)
{
    return find(a) == find(b);
}

double distance(int x1, int y1, int x2, int y2)
{
    return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}

double kruskal()
{
    sort(node+1, node+m+1, cmp);
    double res = 0;
    for (int i = 1; i <= m; i ++) {
        int x = node[i].x, y = node[i].y;
        if (!same(x, y))
            unite(x, y);
        else
            res += node[i].d;
    }
    return res;
}

int main(void)
{
    int a[N+1], b[N+1];
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) {
        scanf("%d%d", &a[i], &b[i]);
    }
    for (int i = 1; i <= m; i ++) {
        scanf("%d%d", &node[i].x, &node[i].y);
        int x = node[i].x, y = node[i].y;
        node[i].d = distance(a[x], b[x], a[y], b[y]);
    }
    init();
    printf("%.3lf\n", kruskal());

    return 0;
}