poj-1251 hdu-1301、poj-1287、poj-2421、zoj-1586、poj-1789、poj-1258、hdu-1233、hdu-1875最小生成树kruskal模板题集合

最新推荐文章于 2019-04-07 11:21:02 发布
最新推荐文章于 2019-04-07 11:21:02 发布
阅读量309 收藏 1
点赞数
分类专栏： 最小生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_CQQ/article/details/80094070
版权

题意： N个顶点的无向图,给你每条边的长度,要你求该图的最小生成树.其中每个点用大写字母A-Z表示.

转换一下输入的格式就好了

链接：poj 1251  && hdu 1301

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 1000 + 10;
const int maxm = 1000000 + 10;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b, c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxn];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal(int n, int m) {
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int main()
{
    int T, kcase = 0;
    while(scanf("%d", &n) && n) {
        char ch;
        int k;
        int a;
        m = 0;
        init();
        for(int i = 1; i < n; i++) {
            cin >> ch >> k;
            char ch1;
            while(k--) {
                cin >> ch1 >> a;
                q[++m].a = ch - 'A' + 1;
                q[m].b = ch1 - 'A' + 1;
                q[m].c = a;
            }
        }
        int ans = kruskal(n, m);
        printf("%d\n", ans);
    }
    return 0;
}

题意：给出n个节点，再有m条边，这m条边代表从a节点到b节点电缆的长度，现在要你将所有节点都连起来，并且使长度最小

裸题。。。。。。

链接：poj 1287

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 10000 + 10;
const int maxm = 1000000 + 10;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b;
    int c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxn];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal(int n, int m) {
    init();
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int main()
{
    int T, kcase = 0;
    while(scanf("%d", &n) && n) {
        scanf("%d", &m);
        for(int i = 1; i <= m; i++) {
           scanf("%d %d %d", &q[i].a, &q[i].b, &q[i].c);
        }
        int ans = kruskal(n, m);
        printf("%d\n", ans);
    }
    return 0;
}

题意：首行给出N，接着是个N*N的矩阵，map[i][j]就代表i到j的权值。接着给出Q，下面Q行，每行两个数字A，B，代表A到B已经有边。最后输出最小生成树的权值和就行

有边的设为0即可

链接：poj 2421

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 10000 + 10;
const int maxm = 1000000 + 10;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b;
    int c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxn];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal(int n, int m) {
    init();
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int gp[maxn][maxn];

int main()
{
    int T, kcase = 0;
    while(scanf("%d", &n) != EOF) {
        int c;
        m = 0;
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d", &gp[i][j]);
            }
        }
        int k;
        scanf("%d", &k);
        int a, b;
        while(k--) {
            scanf("%d %d", &a, &b);
            //a++, b++;
            gp[a][b] = gp[b][a] = 0;
        }
        for(int i = 1; i <= n; i++) {
            for(int j = i + 1; j <= n; j++) {
                q[++m].a = i;
                q[m].b = j;
                q[m].c = gp[i][j];
            }
        }
        int ans = kruskal(n, m);
        printf("%d\n", ans);
    }
    return 0;
}

题意：在一个叫做QS的星系，他们使用一些特殊的通讯方式，两个人之间通讯需要使用一个网络适配器，但是一个网络适配器只能跟一个人联系，所有它连接几个人就需要几个适配器，而且每个人都有一些不同的偏好，喜欢的适配器的牌子也是不同的，现在让你求出来让QS人之间相互通讯最少需要多少代价？
输入第一行是测试数据组数，下面是一个N，代表N个人，下一样有N个数表示每个人喜欢的适配器的价格，接着一个矩阵，表示两点间通讯电缆的价格。

在边权上加上适配器价格即可

链接：zoj 1586

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 1000 + 10;
const int maxm = 1000000;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b;
    int c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxm];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal() {
    init();
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int gp[maxn][maxn];
int price[maxn];

int main()
{
    int T, kcase = 0;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &price[i]);
        }
        int c;
        m = 0;
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d", &gp[i][j]);
                if(j > i) {
                    q[++m].a = i;
                    q[m].b = j;
                    q[m].c = gp[i][j] + price[i] + price[j];
                }
            }
        }
        int ans = kruskal();
        printf("%d\n", ans);
    }
    return 0;
}

题意：给出n个长度相同的字符串，一个字符串代表一个点，每两个字符串有多少个字符不同，则不同的个数即为两点之间的距离，要求各个点都连通求quality的最大值

分母越小越好，转化为最小生成树问题

链接：poj 1789

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 2000 + 10;
const int maxm = 2000000;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b;
    int c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxm];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal() {
    init();
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int gp[maxn][maxn];
int price[maxn];
char str[maxn][105];

int main()
{
    int T, kcase = 0;
    while(~scanf("%d", &n) && n) {
        m = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%s", str[i]);
            for(int j = 1; j < i; j++) {
                int res = 0;
                for(int k = 0; k < strlen(str[i]); k++) {
                    if(str[j][k] != str[i][k]) res++;
                }
                q[++m].a = i;
                q[m].b = j;
                q[m].c = res;
            }
        }
        int ans = kruskal();
        printf("The highest possible quality is 1/%d.\n", ans);
    }
    return 0;
}

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

直接写就行了。。。。。。

链接：poj 1258

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 2200 + 10;
const int maxm = 1001000;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int num[maxn];

int n, m;

struct node {
    int a, b;
    int c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxm];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal() {
    init();
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    //if(nedge < n - 1) ans = -1;
    return ans;
}

int main()
{
    int T, kcase = 0;
    while(~scanf("%d", &n)) {
        m = 0;
        int res;
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d", &res);
                if(j > i) {
                    q[++m].a = i;
                    q[m].b = j;
                    q[m].c = res;
                }
            }
        }
        int ans = kruskal();
        printf("%d\n", ans);
    }
    return 0;
}

题意：中文题

直接kruskal

链接：hdu 1233

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 10000 + 10;
const int maxm = 1000000 + 10;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b, c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxn];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

int kruskal(int n, int m) {
    sort(q + 1, q + 1 + m);
    int ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int main()
{
    int T, kcase = 0;
    while(scanf("%d", &n) && n) {
        init();
        for(int i = 1; i <= n * (n - 1) / 2; i++) {
            scanf("%d %d %d", &q[i].a, &q[i].b, &q[i].c);
        }
        int ans = kruskal(n, n * (n - 1) / 2);
        printf("%d\n", ans);
    }
    return 0;
}

题意： 中文题

注意加边的限制条件，数据类型

链接：hdu 1875

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <vector>
#include <sstream>
#define ll long long

using namespace std;

const int maxn = 10000 + 10;
const int maxm = 1000000 + 10;
const int inf = 0x3f3f3f3f;

int fa[maxn];
int rnk[maxn];

int n, m;

struct node {
    int a, b;
    double c;
    friend bool operator < (node x, node y) {
        return x.c < y.c;
    }
}q[maxn];

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

int getf(int x) {
    if(x != fa[x]) {
        fa[x] = getf(fa[x]);
    }
    return fa[x];
}

void unions(int x, int y) {
    x = getf(x);
    y = getf(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) {
        fa[x] = y;
    }
    else {
        fa[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}

bool same(int x, int y) {
    return getf(x) == getf(y);
}

double kruskal(int n, int m) {
    sort(q + 1, q + 1 + m);
    double ans = 0;
    int nedge = 0;
    for(int i = 1; i <= m && nedge != n - 1; i++) {
        if(getf(q[i].a) != getf(q[i].b)) {
            unions(q[i].a, q[i].b);
            ans += q[i].c;
            nedge++;
        }
    }
    if(nedge < n - 1) ans = -1;
    return ans;
}

int x[maxn], y[maxn];

double dis(int i, int j) {
    return sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
}

int main()
{
    int T, kcase = 0;
    cin >> T;
    while(T--) {
        scanf("%d", &n);
        init();
        m = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%d %d", &x[i], &y[i]);
            for(int j = 1; j < i; j++) {
                if(dis(i, j) >= 10 && dis(i, j) <= 1000) {
                    q[++m].a = i;
                    q[m].b = j;
                    q[m].c = 100 * dis(i, j);
                }
            }
        }
        double ans = kruskal(n, m);
        if(ans != -1)printf("%.1lf\n", ans);
        else puts("oh!");
    }
    return 0;
}





陌离将离
关注
专栏目录
贪心算法：田忌赛马－HDU1052 & POJ2287 & ZOJ2397
CSDN
12-30 5789
  Tian Ji -- The Horse Racing Time Limit: 5 Seconds      Memory Limit: 32768 KB   Here is a famous story in Chinese history. "That was about 2300 years ago. General Tian Ji was a high official in...
计算几何刷题计划（转）
06-14 225
刷题时意外找到了一个好题单,记录一下 POJ 1031Fence 计算视角，要注意角度覆盖大于2*PI的情况POJ 1039Pipe 用叉积判断方向的经典题。枚举两凸点，先计算过这两点能否出左口，若可以再计算最右能到到多远。POJ 1066Treasure Hunt 正方形区域中有n条线段，求从边界到某点最少穿过几条线段。黑书练习题。可BFS，还有更简洁的方法。POJ 1070...
POJ-1258-Agri Ned
weixin_33738555的博客
01-31 114
链接：https://vjudge.net/problem/POJ-1258#author=fuxianda 题意： 有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离任意两个村庄之间的距离小于 100,000. 思路： 最小生成树 代码： #include <ios...
zoj 1586 最小生成树
老铁,干了这碗algorithms的博客
01-08 225
点击打开链接 #include #include #include #include using namespace std; const int maxv=1000+5; const int maxe=500000+5; struct Edge{ int from,to,weight; }; bool operatorconst Edge &E1,const Edge &E2) { r
kuangbin带你飞 专题六 最小生成树 1586（基本都是水题）
Miracle_ma的专栏
07-10 702
做了十来道了，基本都挺水的，主要自己傻，各种数组开小，RE了不少 zoj 1586 题意：貌似就是说给出了许多QS之间的路，然后QS每次只能用一次（每次都有花费） 题解：就是边的权值还得加上两点的花费（都是题意难以理解） for(int i=1;i<=n;i++){ scanf("%d",&val[i]); pre[i]=i;
Agri-Net POJ - 1258 (最小生成树 模板题)
Suprit's blog
04-07 334
Agri-Net POJ - 1258 有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离 任意两个村庄之间的距离小于 100,000. Input 输入包含多组数据。对于每组数据, 第一行包含一个整数N表示农场的数量 (3 <= N <= 100). 接下来是一个NXN的邻接...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
acm-statistics：一种在线工具（爬网程序），用于分析在线裁判（编码比赛网站）中的用户表现。 支持的OJ：POJ，HDU，ZOJ，HYSBZ，CodeForces，UVA，ICPC Live Archive，FZU，SPOJ，Timus（URAL），LeetCode_CN，CSU，LibreOJ，洛谷，牛客OJ，Lutece（UESTC），AtCoder，AIZU， CodeChef，El Judge，BNUOJ，Codewars，UOJ，NBUT，51Nod，DMOJ，VJudge
02-04
此回购包含OJ Hunt的源代码 ...ohunt：一种有状态的独立爬网程序微服务，用于支持某些OJ（例如ZOJ）。 build：用于构建和部署项目的代码。 工具链：docker，docker-compose，GNU make。 工具：正在运行的实用程序脚
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
POJ、HDU、ZOJ、SOJ水题过滤器
11-08
标题中的“POJ、HDU、ZOJ、SOJ水题过滤器”指的是一个工具，它主要用于帮助在ACM（国际大学生程序设计竞赛）训练中筛选出这些在线判题系统中的简单题目，即所谓的“水题”。这些在线判题平台是编程爱好者和参赛者们...
Agri-Net
smoggyxhdz的博客
11-21 286
有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离 Input The input includes several cases. For each case, the first line contains the number of farms, N (3 <= N <= 100).
poj 1258 Agri-Net
purevegetable
09-07 725
最小生成树的题，直接用prime就可以解决，模板题吧。      #include #include #include #define INF 0x3f3f3f3f using namespace std; const int N = 105; int map[N][N], n, ans, dis[N]; bool vis[N]; void pri() { vis[1] =
ZOJ 1586 QS Network（最小生成树）
linlinsong—ACM界蒟水！
05-01 1193
Sunny Cup 2003 - Preliminary RoundApril 20th, 12:00 - 17:00Problem E: QS NetworkIn the planet w-503 of galaxy cgb, there is a kind of intelligent creature named QS. QScommunicate with each other via ne
POJ 1258 Agri-Net（最小生成树-Prim）
sunlanchang的博客
07-31 355
Description 有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离 Input 第一行一个整数n表示农场个数（3<=n<=100）,然后是n个农场的距离矩阵 Output 输出安装光纤的最小总距离 Sample Input 4 0 4 9 21 4 0
POJ 1586 Three Sides Make a Triangle G++ 几何 巧妙 背
woniupengpeng的专栏
05-28 774
给出三角形三个点的坐标。判断三角形是否是没等边的三角形、等腰三角形、等边三角形；是否是锐角三角形、直角三角形、钝角三角形。
kuangbin专题六 POJ1258 Agri-Net
Start_to_crazy的博客
01-05 263
题意： 有n个农场，已知这n个农场都互相相通，有一定的距离，现在每个农场需要装光纤，问怎么安装光纤能将所有农场都连通起来，并且要使光纤距离最小，输出安装光纤的总距离。 题解： 最小生成树模板。//prim #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; #define I
ZOJ 1586 QS Network(最小生成树)
henuzxy
08-22 395
Sunny Cup 2003 - Preliminary RoundApril 20th, 12:00 - 17:00Problem E: QS NetworkIn the planet w-503 of galaxy cgb, there is a kind of intelligent creature named QS. QScommunicate with each other via ne
poj1586 最小生成树
Joel
01-17 296
题目链接在这里 题目大意： 一个星球之间的居民想相互之间建立联系。建立联系需要每户购买设备，每个设备只能供和一位其他居民联系。居民和居民之间有距离，每个居民购买设备的价格也不一样。问如果让所有的居民之间相互建立联系，最少需要花费多少。 解题思路： 每个居民之间两两建边，边的权值是两者之间的距离加上每户人家购买设备的价格的总和。然后根据这些边建立最小生成树。 代码如下： #includ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值