kuangbin专题六 最小生成树题解

最新推荐文章于 2023-01-31 23:35:02 发布
最新推荐文章于 2023-01-31 23:35:02 发布
阅读量373 收藏
点赞数
分类专栏： kuangbin题解 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChaningLou/article/details/114288681
版权

kuangbin专题六 最小生成树

A. A Jungle Roads POJ - 1251（节点编号处理）

模板题，把字符经过 - 'A' + 1 处理为从1开始的节点编号。稠密无向图，用邻接矩阵存，对称地存储最小的距离（以防有重边）。套用prim()模板

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30;
const int INF = 0x3f3f3f3f;

int n, k;

bool st[N];
int dist[N];
int d[N][N];

int prim()
{
    int res = 0;
    memset(dist, INF, sizeof dist);
    memset(st, false, sizeof st);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;

        res += dist[t];

        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], d[t][j]);

        st[t] = true;
    }
    return res;
}

int main()
{
    while(cin >> n, n)
    {
        memset(d, INF, sizeof d);
        for(int i = 1; i <= n - 1; ++ i)
        {
            char uu, vv;
            int w;
            cin >> uu >> k;
            for(int j = 1; j <= k; ++ j)
            {
                cin >> vv >> w;
                int u = uu - 'A' + 1, v = vv - 'A' + 1;
                d[u][v] = d[v][u] = min(w, d[u][v]);
            }
        }
        cout << prim() << endl;
    }
    return 0;
}
B. Networking POJ - 1287（重边处理）

模板题，注意重边，用邻接矩阵 存最小边权

C. Building a Space Station POJ - 2031（存在现有边 + 边权处理）

如果球相交或相切，则存在现成边，否则把边权设为两球距离 - 两球半径和。存在现成的边处理方法：

  1. prim：d[i] [j] = 0 kruskal：并查集p[pa] = pb，不用把这条边加进边集
  2. 把现成的边加入边的计数器，最终最小生成树的为边数n - 1

注意：printf 输出 double 用 %.03f

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
const int N = 100 + 10;
const double INF = 0x42;

//printf 输出 double 用 %.03f !!!

int n;

double d[N][N];
double dist[N];
bool st[N];

struct Sphere
{
    double x, y, z, r;
}p[N];

double getDist(Sphere a, Sphere b)
{
    return sqrt(double((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) + (a.z - b.z) * (a.z - b.z));
}

double prim()
{
    int cnt = 0;
    double res = 0.0;
    memset(st, false, sizeof st);
    memset(dist, INF, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if(i && dist[t] == INF)     return INF;
        if(i)                       res += dist[t];

        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], d[t][j]);

        st[t] = true;

        ++ cnt;
    }
    if(cnt < n - 1)     return INF;
    return res;
}

int main()
{
    while(cin >> n, n)
    {
        memset(d, INF, sizeof d);

        for(int i = 1; i <= n; ++ i)
        {
            double x, y, z, r;
            scanf("%lf%lf%lf%lf", &x, &y, &z, &r);
            p[i] = {x, y, z, r};
        }

        for(int i = 1; i <= n; ++ i)
            for(int j = 1; j <= n; ++ j)
                {
                    double distance = getDist(p[i], p[j]);
                    if(distance >= p[i].r + p[j].r)
                        d[i][j] = d[j][i] = distance - (p[i].r + p[j].r);
                    else
                        d[i][j] = d[j][i] = 0.0;
                }

        double ans = prim();

        printf("%.3f\n", ans);

    }

    return 0;
}
D. Constructing Roads POJ - 2421（存在现成边）

存在现成边，预处理现成边之后再套模板

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 100 + 10;

//遇到 runtime 检查 数组 是不是开太小了
//边 老老实实 点数 的 平方
const int M = N * N;
const int INF = 0x3f3f3f3f;

//特点：建树之前 已经 提前有了边  kruskal + 并查集 走起来
//如果已经 a - b 联通了  判断pa == pb ！！！
// ① 修改p[pa] = pb
// ② 加上最小生成树 当前边数

//邻接矩阵  不用再数边 n - 1了

//如果数组不能用循环赋值， 考虑 i <= n 的 n 是不是 还没有 赋值

int n, p[N], q, a, b;

int idx = 0;
int res = 0;

//当前边是否已经加过
int d[N][N];
int cntEdge = 0;

struct Edge
{
    int a, b, w;
    bool operator < (const Edge & rhs) const
    {
        return w < rhs.w;
    }
}edge[M];

int find(int x)
{
    return p[x] == x ? x : p[x] = find(p[x]);
}

int kruskal()
{
    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;

        //还没被加进树中

        int pa = find(aa), pb = find(bb);
        if(pa != pb)
        {
            res += edge[i].w;
            ++ cntEdge;
            p[pa] = pb;
        }

        //已经在树中了
        else
            continue;
    }
    if(cntEdge < n - 1) return INF;
    else                return res;
}

int main()
{
    cin >> n;

    for(int i = 1; i <= n; ++ i)    p[i] = i;

    for(int i = 1; i <= n; ++ i)
        for(int j = 1; j <= n; ++ j)
        {
            scanf("%d", &d[i][j]);
            if(i != j)
                edge[idx ++] = {i, j, d[i][j]};
        }

    sort(edge, edge + idx);

    //加入已经存在的边，res 要先加上， cnt也要先算上
    cin >> q;
    for(int i = 1; i <= q; ++ i)
    {
        scanf("%d%d", &a, &b);

        ++cntEdge;

        int pa = find(a), pb = find(b);
        p[pa] = pb;
    }

    int ans = kruskal();

    cout << ans << endl;

    return 0;
}
E. QS Network ZOJ - 1586（边权处理）

若两个节点之间建边，费用除了它们边权，还要加上两个点权， 求最小生成树。要想求最小价值，必须算边及顶点的权值和。

解决方法：用prim算法，在构造邻接矩阵时，在i到j的权值的基础上再加上i点的权值和j点的权值即可。

scanf("%d", &g[i][j]);
g[i][j] += (cost[i] + cost[j]);

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e3 + 50;
const int INF = 0x3f3f3f3f;

int n;

int g[N][N];
int cost[N];
int dist[N];
bool st[N];

int prim()
{
    int res = 0, cnt = 0;
    memset(st, false, sizeof st);
    memset(dist, INF, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        res += dist[t];
        st[t] = true;
        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], g[t][j]);
    }
    return res;
}

int main()
{
    int T;
    cin >> T;
    while(T -- )
    {
        cin >> n;
        for(int i = 1; i <= n; ++ i)
            scanf("%d", &cost[i]);

        for(int i = 1; i <= n; ++ i)
            for(int j = 1; j <= n; ++ j)
            {
                scanf("%d", &g[i][j]);
                g[i][j] += (cost[i] + cost[j]);
            }

        cout << prim() << endl;
    }
    return 0;
}
F. Truck History POJ - 1789（边权处理）

给出n个长度为7的字符串，每个字符串代表一个车ID，定义车ID的距离是两个字符串间不同字母的个数，题目要求的数不同的车的距离的最小值，即所求的就是最小生成树。

int cnt = 0;
for(int k = 0; k < types[1].size(); ++ k)
	if(types[i][k] != types[j][k])
		++cnt;
edge[idx ++ ] = {i, j, cnt};

#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 2000 + 10;
const int M = N * N / 2;

string types[N];
int n;

int p[N];

int find(int x)
{
    return p[x] == x ? p[x] : p[x] = find(p[x]);
}

struct Edge
{
    int a, b, w;
    bool operator < (const Edge & rhs) const
    {
        return w < rhs.w;
    }
}edge[M];

int idx;

int kruskal()
{
    int res = 0;
    sort(edge, edge + idx);

    for(int i = 1; i <= n; ++ i)    p[i] = i;

    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;
        int pa = find(aa), pb = find(bb);
        if(pa != pb)
        {
            res += edge[i].w;
            p[pa] = pb;
        }
    }
    return res ;
}


int main()
{
    while(cin >> n, n)
    {
        idx = 0;
        for(int i = 1; i <= n; ++ i)
            cin >> types[i];

//        cout << types[1][0] << endl;
//        cout << types[2][0] << endl;

        for(int i = 1; i <= n - 1; ++ i)
            for(int j = i + 1; j <= n; ++ j)
            {
                int cnt = 0;
                for(int k = 0; k < types[1].size(); ++ k)
                    if(types[i][k] != types[j][k])
                        ++cnt;
                edge[idx ++ ] = {i, j, cnt};
            }

//        cout << kruskal() << endl;
        printf("The highest possible quality is 1/%d.\n", kruskal());
    }
    return 0;
}
G. Arctic NetworkPOJ - 2349（边数处理：s - 1条免费边）

S颗卫星可以代替S-1条边，基于贪心思想，代替的边越长，求得的D就越小。所以可以用一个vector保存加入最小生成树的边的长度，共有P-1条边，把前S-1条较长的边代替掉，剩下的边中最长的即为所求

理解：

删一条边时 ： 一条边 一头在 T 中， 一头 成为 一个 独立的 连通支，所以 删一条边 == 删掉 T 中 的一个 点

具体就是：s - 1 个 卫星 把 删边 弄出来的 s 个联通支 联通。 剩下一个 给 T，这样整个图就联通了

#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>

// S颗卫星可以代替S-1条边，基于贪心思想，代替的边越长，求得的D就越小。所以可以用一个vector保存加
// 入最小生成树的边的长度，共有P-1条边，把前S-1条较长的边代替掉，剩下的边中最长的即为所求

// 无向图的一个 最大 连通 子图 称为一个 连通支 (connected component).

// 删一条边时 ： 一条边 一头在 T 中， 一头 成为 一个 独立的 连通支
// 删一条边 == 删掉 T 中 的一个 点
// s - 1 个 卫星 把 删边 弄出来的 s 个联通支 联通。 剩下一个 给 T，这样整个图就联通了

using namespace std;
const int N = 500 + 10;
const int M = N * (N - 1) / 2;

int s, p;
int idx = 0;

int par[N];

int find(int x)
{
//    while(x != par[x])  x = par[x];
    return par[x] == x ? x : par[x] = find(par[x]);
}

struct Point
{
    int x, y;
}point[N];

struct Edge
{
    int a, b;
    double w;
    bool operator < (const Edge & rhs) const
    {
        return w < rhs.w;
    }
}edge[M];

vector<Edge> mst;

void kruskal()
{
    for(int i = 1; i <= p; ++ i)    par[i] = i;

    sort(edge, edge + idx);

    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;
        int pa = find(aa), pb = find(bb);
        if(pa != pb)
        {
            par[pa] = pb;
            mst.push_back(edge[i]);
        }
    }
}

int main()
{
    int n;
    cin >> n;
    while(n --)
    {
        idx = 0;
        mst.clear();
        cin >> s >> p;
        for(int i = 1; i <= p; ++ i)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            point[i] = {a, b};
        }

        for(int i = 1; i <= p - 1; ++ i)
            for(int j = i + 1; j <= p; ++ j)
                edge[idx ++ ] = {i, j, sqrt((double) (point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y))};

        kruskal();

//        for(int i = 1; i <= s; ++ i)    mst.pop_back();

        for(int i = 1; i <= p; ++ i)    par[i] = i;
        int tt = mst.size() - 1 - (s - 1);

        printf("%0.2f\n", mst[tt].w);

    }
    return 0;
}
H. Highways POJ - 1751（现成边 + 输出边）

预处理现成边，kruskal 稍加改动，加上输出边起点终点的语句

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
const int N = 750 + 10;

//建边  a - b  b - a 不重复建！！！

const int M = N * N;

//特点：建树之前 已经 提前有了边      1751 Highways + 2421 Constructing road
//  kruskal + 并查集 把p[pa] = pb a、b合并起来
//  或者 prim 把联通的 两点 无向边 权重 设为 0
//如果数组不能用循环赋值， 考虑 i <= n 的 n 是不是 还没有 赋值

int n, p[N], q, a, b;

int idx = 0;

//当前边是否已经加过
//bool st[N][N];
int cntEdge = 0;

struct Edge
{
    int a, b;
    double w;
    Edge(int aa, int bb, double ww): a(aa), b(bb), w(ww) {};
    Edge(){}
    bool operator < (const Edge & rhs) const
    {
        return w < rhs.w;
    }
}edge[M];

struct Point
{
    int x, y;
}point[N];

int find(int x)
{
    return p[x] == x ? x : p[x] = find(p[x]);
}

void kruskal()
{
    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;

        //不连通
        int pa = find(aa), pb = find(bb);
        if(pa != pb)
        {
            ++ cntEdge;
            p[pa] = pb;
            cout << aa << ' ' << bb << endl;
        }

        if(cntEdge == n )    break;
    }
}

int main()
{
    while(cin >> n)
    {
        cntEdge = 0;
        idx = 0;

        for(int i = 1; i <= n; ++ i)    p[i] = i;

        for(int i = 1; i <= n; ++ i)
            scanf("%d%d", &point[i].x, &point[i].y);

        //建边  a - b  b - a 不重复建！！！
        for(int i = 1; i <= n - 1; ++ i)
            for(int j = i + 1; j <= n; ++ j)
                edge[idx ++] = Edge(i, j, sqrt((double) ((point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y))));

        sort(edge, edge + idx);

        //加入已经存在的边，res 要先加上， cnt也要先算上
        cin >> q;
        for(int i = 1; i <= q; ++ i)
        {
            scanf("%d%d", &a, &b);
            int pa = find(a), pb = find(b);

            if(pa != pb)
            {
                ++cntEdge;
                p[pa] = pb;
            }
        }

        kruskal();
    }
    return 0;
}
I. Agri-Net POJ - 1258（邻接矩阵 朴素prim）

套模板

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 100 + 10;
const int INF = 0x3f3f3f3f;
//邻接矩阵 + 完全图 朴素prim算法

int n;

int d[N][N];
int dist[N];
bool st[N];

int prim()
{
    int res = 0;
    memset(st, false, sizeof st);
    memset(dist, INF, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        res += dist[t];

        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], d[t][j]);

        st[t] = true;
    }
    return res;
}

int main()
{
    while(cin >> n)
    {
        for(int i = 1; i <= n; ++ i)
            for(int j = 1; j <= n; ++ j)
                scanf("%d", &d[i][j]);

        int ans = prim();

        cout << ans << endl;
    }

    return 0;
}
J. Borg Maze POJ - 3026（BFS + 字符输入处理）

给出BFS标准地图，图里面有节点（无编号）。遍历地图，新建id[N][N]把节点的位置编号和地图上的位置对应起来，对每个点进行BFS求到其他点的距离。地图每行后面可能还会有多余的空格，很坑，要用fgets吸收 空格 + 回车

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int L = 100 + 10;      //地图规模
const int N = 100 + 10;     //点 的数量
const int INF = 0x3f3f3f3f;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

int c, r;
char g[L][L];
int d[L][L];
int id[L][L];
int dist[N];
int stMST[N];
int idx, e;

bool st[L][L];

struct Point
{
    int x, y, step;
}point[N];

//搜到一个点 把 当前坐标 和 这个点 的编号 对应起来
void bfs(int p)
{
    memset(st, false, sizeof st);
    int idFrom = id[point[p].x][point[p].y];
    queue<Point> q;
    q.push(point[p]);
    st[point[p].x][point[p].y] = true;

    while(!q.empty())
    {
        Point top = q.front();
        q.pop();
        for(int i = 0; i < 4; ++ i)
        {
            int x = top.x, y = top.y;
            int nx = x + dx[i], ny = y + dy[i];
            if(!st[nx][ny] && g[nx][ny] != '#' && nx <= r && nx >= 1 && ny <= c && ny >= 1)
            {
                int idTo = id[nx][ny];
                Point next = {nx, ny, top.step + 1};
                st[nx][ny] = true;
                q.push(next);
                if(g[nx][ny] == 'S' || g[nx][ny] == 'A')
                    d[idFrom][idTo] = next.step;
            }
        }
    }
}

int prim()
{
    int res = 0;
    memset(dist, INF, sizeof dist);
    memset(stMST, false, sizeof stMST);
    dist[1] = 0;

    for(int i = 0; i < idx; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= idx; ++ j)
            if(!stMST[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        stMST[t] = true;
        res += dist[t];

        for(int j = 1; j <= idx; ++ j)
            dist[j] = min(dist[j], d[t][j]);
    }
    return res;
}

int main()
{
    int n;
    cin >> n;
    while(n --)
    {
        e = idx = 0;
        memset(id, 0, sizeof id);
//        scanf("%d%d", &c, &r);

        cin >> c >> r;
        char tmp[1024];
        fgets(tmp, 1000, stdin);

        for(int i = 1; i <= r; ++ i)
        {
            fgets(&g[i][1], 1000, stdin);
            for(int j = 1; j <= c; ++ j)
                if(g[i][j] == 'A' || g[i][j] == 'S')
                {
                    point[++ idx] = {i, j, 0};
                    id[i][j] = idx;
                }
        }

        for(int i = 1; i <= idx; ++ i)   bfs(i);

        cout << prim() << endl;
//        cout << 1 << endl;
    }
    return 0;
}
K. The Unique MST POJ - 1679（次小生成树）

小白做法：

  1. 先做一遍kruskal， 把用到的边存进vector
  2. 再依次做n - 1次kruskal，每次做的时候 依次跳过 vector 里面的边，判断次小生成树是否 == MST

注意：kruskal2 每次做完都要判断 是否 联通， 可能出现删除关键边 导致 图无法连通的情况

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
const int INF = 0x3f3f3f3f;
const int N = 100 + 10;
const int M = 5e3 + 50;

// 先做一遍kruskal， 把用到的边存进vector
// 再依次做n - 1次kruskal，每次做的时候 跳过 vector 里面的边
// 注意：kruskal2 每次做完都要判断 是否 联通， 可能出现删除关键边 导致 图无法连通的情况

using namespace std;
int n, m, idx;

int p[N];

int find(int x)
{
    return p[x] == x ? x : p[x] = find(p[x]);
}

struct Edge
{
    int a, b, w;
    bool operator < (const Edge & rhs) const
    {
        return w < rhs.w;
    }
}edge[M];

vector<Edge> mst;

//第一次求出MST1
int kruskal1()
{
    int res = 0, cnt = 0;
    sort(edge, edge + idx);
    for(int i = 1; i <= n; ++ i)    p[i] = i;

    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;
        int pa = find(aa), pb = find(bb);
        if(pa != pb)
        {
            mst.push_back(edge[i]);
            p[pa] = pb;
            res += edge[i].w;
            ++ cnt;
        }
    }
    return res;
}

//跳过 vector 里 第IDOfDeleteEdge条 边，切记要判断 删除边 后 图是否还联通
int kruskal2(int IDOfDeleteEdge)
{
    int res = 0, cnt = 0;
    int flag = 0;
    for(int i = 1; i <= n; ++ i)    p[i] = i;

    for(int i = 0; i < idx; ++ i)
    {
        int aa = edge[i].a, bb = edge[i].b;
        int pa = find(aa), pb = find(bb);

        if(mst[IDOfDeleteEdge].w == edge[i].w && mst[IDOfDeleteEdge].a == aa && mst[IDOfDeleteEdge].b == bb)
            continue;

        if(pa != pb)
        {
            p[pa] = pb;
            res += edge[i].w;
            ++ cnt;
        }
    }
    if(cnt == n - 1)
        return res;
    return INF;
}

int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        mst.clear();
        bool notUnique = false;
        idx = 0;
        cin >> n >> m;
        for(int i = 1; i <= m; ++ i)
        {
            int x, y, w;
            scanf("%d%d%d", &x, &y, &w);
            edge[idx ++ ] = {x, y, w};
        }

        int MST1 = kruskal1();

        for(int i = 0; i < mst.size(); ++ i)
        {
            int MST2 = kruskal2(i);
            if(MST1 == MST2)    notUnique = true;
        }
        if(notUnique)   puts("Not Unique!");
        else            cout << MST1 << endl;
    }
    return 0;
}
L. 还是畅通工程 HDU - 1233（邻接矩阵 朴素prim）

套模板

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 100 + 10;
const int INF = 0x3f3f3f3f;
int n;

bool st[N];
int d[N][N];
int dist[N];

int prim()
{
    int res = 0;
    memset(dist, INF, sizeof dist);
    memset(st, false, sizeof st);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        st[t] = true;
        res += dist[t];

        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], d[t][j]);
    }
    return res;
}

int main()
{
    while(~scanf("%d", &n), n)
    {
        for(int i = 1; i <= n * (n - 1) / 2; ++ i)
        {
            int a, b, w;
            scanf("%d%d%d", &a, &b, &w);
            d[a][b] = d[b][a] = w;
        }

        int ans = prim();

        cout << ans << endl;
    }
    return 0;
}
M. Jungle Roads HDU - 1301

同第一题

N. 畅通工程再续 HDU - 1875（边权处理 + 坐标计算距离）

点距离公式 + 套模板

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int N = 100 + 10;
const double INF = 0x42;

int n;

double d[N][N];
double dist[N];
bool st[N];

struct point
{
    int x, y;
}p[N];

double getDist(point a, point b)
{
    return sqrt(double((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)));
}

double prim()
{
    int cnt = 0;
    double res = 0.0;
    memset(st, false, sizeof st);
    memset(dist, INF, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; ++ i)
    {
        int t = -1;
        for(int j = 1; j <= n; ++ j)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if(i && dist[t] == INF)     return INF;
        if(i)                       res += dist[t];

        for(int j = 1; j <= n; ++ j)
            dist[j] = min(dist[j], d[t][j]);

        st[t] = true;

        ++ cnt;
    }
    if(cnt < n - 1)     return INF;
    return res;
}

int main()
{
    int T ;
    cin >> T;
    while(T --)
    {
        memset(d, INF, sizeof d);

        cin >> n;
        for(int i = 1; i <= n; ++ i)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            p[i] = {x, y};
        }

        for(int i = 1; i <= n; ++ i)
            for(int j = 1; j <= n; ++ j)
            {
                double distance = getDist(p[i], p[j]);
                if(distance == 0 || distance >= 10 && distance <= 1000)
                    d[i][j] = distance;
            }

        double ans = prim();
        if(ans < 1e9)
            printf("%.1f\n", ans * 100);
        else
            puts("oh!");
    }

    return 0;
}
_ChanningLau_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树所有题解
qq_62767608的博客
02-16 1237
1.今天学习了Kruskal算法和Prim算法。 2.完成最小生成树的所有题目。 - [P3366 【模板】最小生成树](https://www.luogu.com.cn/problem/P3366) 题解：该题为模板题，我用的是Kruskal算法。 Kruskal算法核心思想：将所有边根据边权从小到大排序，每次从剩余的边中选择权值较小且边的两个顶点不在同一个集合的边（即不会产生回路的边），加入到生成树中，直到加入了n-1条边为止。 //kruskal #include<bits/st
【u028】数列的整除性
10-06 346
Time Limit: 1 second Memory Limit: 128 MB 【问题描述】 对于任意一个整数数列，我们可以在每两个整数中间任意放一个符号'+'或'-'，这样就可以构成一个表达式，也就可以计算出表达式的值。比如，现在有一个整数数列：17，5，-2，-15，那么就可以构造出8个表达式： 17+5+（-21）+15=16 17+5+（-21）-15=-14 17+5...
搜索与图论-最小生成树（Prim 算法和 Kruskal 算法）
最新发布
每天进步一点点！
01-31 1511
Prim（普里姆）算法或 Kruskal（克鲁斯卡尔）算法求最小生成树
算法笔记_图算法专题_最小生成树
一个努力生活的人的博客
05-12 184
最小生成树 1.基本概念 1.定义： （1）在给定一个无向图中求一棵树T （2）使得这棵树拥有图G的所有顶点，边都是来自图G的边 （3）并且满足边权之和最小 2.性质： （1）因为是树，所以边数=顶点数-1 （2）对给定的图G，其最小生成树可以不唯一，但边权之和一定是唯一的 （3）根节点可以是这棵树上的任意一个结点 2.最小生成树的求法 （1）prim算法 特点：类似于Dijkstra算法，只是在求解最短距离时，用集合S代替了起点s 伪代码： Prim(G,d[]){ 初始化; for(循环n
例4.15 奖金（拓扑排序）
weixin_33877092的博客
02-09 261
#include<iostream> #include<cstdio> #include<cstring> #include<string> #include<algorithm> int n,m; int f[10001]; int tree[10001][301]; int r[10001],ans=0; usi...
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
在ACM竞赛中，图论问题常见于最小生成树（如Prim算法或Kruskal算法）、最短路径（Dijkstra算法、Floyd-Warshall算法等）、强连通分量识别、寻找桥和割点等。这些概念和算法对于解决复杂网络问题有着至关重要的作用。...
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
《kuangbin的ACM模板（新）》是一个专门针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）比赛设计的算法模板，由知名程序员kuangbin提供。这个压缩包包含了一份kuangbin的ACM算法...
c++指针基础练习相关记录
weixin_43528481的博客
08-13 89
一. int* pt; pt = &higgens; #include <iostream> #include <cstdio> #include<string> #include<Cmath> #include<CString> using namespace std; int main() { int higgens = 5; int* pt; pt = &higgens; cout << " &a
【数学与算法】Prim算法 - 寻找无向图中最小生成树
u011754972的博客
10-11 665
Prim's 算法的基本想法是： 种一棵树，让树从一个节点增长到n个节点。 初始时，树只有一个节点，可以是n个节点中的任意一个，没有边(这是肯定的，两个节点才会有边)； 每一轮循环会找出一个节点和一条边，把他们接到树上，这样树会变大一点。 整个过程都要保证树的两个性质： 1.树是连通图； 2.树没有回路； 算法循环次数等于节点的数量；这是因为，每一轮循环就会往树里添加一个节点。 例子： 算法的输入是一张连通的无向图，如下： 使用集合U记录生成的树的节点。下面的介绍中，使用红色标出集合U中的节点，
最小生成树算法
qq_43533956的博客
04-10 1653
生成树 指的是「无向图」中，具有该图的 全部顶点 且 边数最少 的连通子图。最小生成树指的是「加权无向图」中总权重最小的生成树。 连接所有点的最小费用 给你一个points 数组，表示 2D 平面上的一些点，其中 points[i] = [xi, yi] 。 连接点 [xi, yi] 和点 [xj, yj] 的费用为它们之间的 曼哈顿距离 ：|xi - xj| + |yi - yj| ，其中 |val| 表示 val 的绝对值。 请你返回将所有点连接的最小总费用。只有任意两点之间 有且仅有 一条简单
无向带权图的最小生成树算法——Prim及Kruskal算法思路
热门推荐
Java 之 道
03-30 2万+
边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。    构造网的最小生成树必须解决下面两个问题：     1、尽可能选取权值小的边，但不能构成回路；
最小生成树——HDU1233
jhckii的博客
02-13 96
#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #define ll long long using namespace std; //const int mod=; #define INF 0x3f3f3f3f const int maxn=1e6+10;...
kuangbin 专题六：最小生成树 Constructing Roads
weixin_45867800的博客
10-06 88
题目链接： 传送门 1.方法一：kruskal #include<iostream> #include<cstring> #include<algorithm> using namespace std; const int N = 200010; int p[N], n, q, s, e, val; struct edge { int u, v, w; } edges[N]; //初始化父结点（并查集） void init() { for(int i = 0; i
使用#include<bits/stdc++.h>包含C++的所有头文件
cumtcyf的博客
09-18 2579
参考博客：http://blog.csdn.net/u011466175/article/details/24638621?utm_source=tuicool&utm_medium=referral #include这个头文件包含以下等等C++中包含的所有头文件，这个是C++版本升级： #include #include #include #include #
求无向连通图的最小生成树算法——Prim与Kruska
changli_90的专栏
12-07 8247
http://hi.baidu.com/%CA%FD%BE%DD%BD%E1%B9%B9%BF%CE%B3%CC/blog/item/fd0dd984f3b99126c75cc39c.html 求无向连通图的最小生成树算法——Prim与Kruskal及相关优化 数据结构课程 最小生成树是图论里很重要的部分。但是由于它属于图论所以NOIP基本不考，对于NOI又太基础，所以竞赛中出现
算法：通过普利姆(Prim)算法，求出图的最小生成树
weixin_39448458的博客
09-09 4829
请看如下的示例图，该图有 V1-V7 七个顶点，每个顶点之间的距离如图所示： 如果上面的图为七个城市的地理分布图，城市间相连的边上的数字为城市间的距离。我们要在这七个城市里面架设电线，使得每一个城市都在电网之中，怎么样架设电线，可以使得所使用的电线最短呢？ 这就是图论里面的最小生成树的问题，今天我们用普利姆(Prim)算法，来求得电线架设的方案。话不多说，精髓全在代码和其间的注释里，可复制到ID...
ACM模板：字符串处理与数学算法详解
"ACM常用算法模板文档由kuangbin提供，收录了丰富的字符串处理、数学及相关数论算法。该模板主要分为两个部分：字符串处理和数学。 在字符串处理章节，核心算法包括： 1. KMP (Knuth-Morris-Pratt)算法，用于在文本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值