HDU 3405

World Islands

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1493    Accepted Submission(s): 594

Problem Description

Dubai
is a haven for the rich. The government of Dubai finds a good way to
make money. They built a lot of artificial islands on the sea and sell
them. These islands are shaped into the continents of the world, so they
are called “world islands”. All islands are booked out now. The
billionaires who buy these islands wants to make friends with each
other, so they want these islands all be connected by bridges. Bill
Gates also has booked an island, but he is the only one who doesn’t want
his island to be connected with other islands, because he prefer to
travel on the sea on his old landing craft which is used in the Invasion
of Normandy in World War II. Fortunately, Bill doesn’t care about which
island is saved for him, so Dubai government can still find the best
way to build the bridges. The best way means that the total length of
the bridges is minimum. In a word, if there are n islands, what they
should do is to build n–2 bridges connecting n-1 islands, and give the
rest island to Bill Gates. They can give any island to Bill Gates. Now
they pay you good money to help them to find out the best way to build
the bridges.
Please note;
1.An island can be considered as a point.
2.A bridge can be considered as a line segment connecting two islands.
3.A bridge connects with other bridges only at the islands.

Input

The first line is an integer indicating the number of test cases.
For each test case, the first line is an integer n representing the number of islands.(0<n<50)
Then
n lines follow. Each line contains two integers x and y( -20 <= x, y
<= 20 ) , indicating the coordinate of an island.

Output

For
each test case, output the minimum total length of the bridges in a
line. The results should be rounded to 2 digits after decimal point, and
you must keep 2 digits after the decimal point.

Sample Input

2

5

0 0

1 0

18 0

0 1

1 1

3

0 0

1 0

0 1

Sample Output

3.00

1.00

billionaires

想买一座岛,但他不想让自己的岛与其他岛相连,所以在剩下的n-1座岛屿之间架桥,最短路径是多少

PS:自己刚开使只用了一个Kruskal  wa 必须遍历

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 0x3f3f3f3f
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int f[70];
int n,m,t;
struct Node
{
    double x;
    double y;
}node[55];
struct E
{
    int u;
    int v;
    double w;
    friend bool operator<(const E &a,const E&b)
    {
        return a.w<b.w;
    }
}e[3000];
double dist(Node a,Node b)
{
    return (double)sqrt(((a.x-b.x)*(a.x-b.x)*1.0)+((a.y-b.y)*(a.y-b.y)*1.0));
}
int find(int x)
{
    return f[x]==x?x:find(f[x]);
}
double kruskal()
{
    double ans=0.0;
    int k=1,q=n-1;
    for(int i=0;i<=n;i++)
    {
        f[i]=i;
    }
    for(int i=0;i<m;i++)
    {
        int u=find(e[i].u);
        int v=find(e[i].v);
        if(u!=v)
        {
            ans+=e[i].w;
            if(u<v) f[u]=v;
            else f[v]=u;
            k++;
            if(k==q) break;
        }
    }
    return ans;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%lf %lf",&node[i].x,&node[i].y);
        }
        double ans=1000000.0;
        for(int k=0;k<n;k++)
        {
            m=0;
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(i==k || j==k) continue;
                    e[m].u=i;
                    e[m].v=j;
                    e[m++].w=dist(node[i],node[j]);
                }
            }
            sort(e,e+m);
            ans=min(ans,kruskal());
        }
        printf("%.2f\n",ans);
    }
    return 0;
}
时间: 2024-12-21 17:20:50

HDU 3405的相关文章

HDU - 3405 - World Islands

先上题目: World Islands Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 888    Accepted Submission(s): 345 Problem Description Dubai is a haven for the rich. The government of Dubai finds a good way

hdu 3405 删掉某点后 求最小生成树

给出N个点的坐标 边的权值为两点间的距离 删掉其中某点 求最小生成树的权值和 要求这权值最小 因为最多50个点 所以具体是删哪个点 用枚举假如有4个点 就要求4次最小生成树 分别是2 3 4 | 1 3 4 | 1 2 4 | 1 2 3 这些点的 Sample Input250 01 018 00 11 130 01 00 1 Sample Output3.001.00 prim 1 # include <iostream> 2 # include <cstdio> 3 # in

Poj 3771 hdu 3405

poj 3771 http://poj.org/problem?id=3771 wiki Prim http://zh.wikipedia.org/wiki/%E6%99%AE%E6%9E%97%E5%A7%86%E7%AE%97%E6%B3%95 prim 算法水题 之前写过类似的题,一直以为直接暴力,从遍历所有的点为起点,寻找距离起点最短的点然后再在改点上寻找最短距离 这摆明了是划线嘛……根本不是图论啊啊啊!!!! 这样真是萌萌哒…… 正确的做法是先枚举所有的点作为起点,然后把距离长的点更新

hdu 2112 (最短路+map)

链接:http://acm.hdu.edu.cn/showproblem.php?pid=2112 HDU Today Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 14515    Accepted Submission(s): 3405 Problem Description 经过锦囊相助,海东集团终于度过了危机,从此,HDU的发

HDU 6203 ping ping ping [LCA,贪心,DFS序,BIT(树状数组)]

题目链接:[http://acm.hdu.edu.cn/showproblem.php?pid=6203] 题意 :给出一棵树,如果(a,b)路径上有坏点,那么(a,b)之间不联通,给出一些不联通的点对,然后判断最少有多少个坏点. 题解 :求每个点对的LCA,然后根据LCA的深度排序.从LCA最深的点对开始,如果a或者b点已经有点被标记了,那么continue,否者标记(a,b)LCA的子树每个顶点加1. #include<Bits/stdc++.h> using namespace std;

HDU 5542 The Battle of Chibi dp+树状数组

题目:http://acm.hdu.edu.cn/showproblem.php?pid=5542 题意:给你n个数,求其中上升子序列长度为m的个数 可以考虑用dp[i][j]表示以a[i]结尾的长度为j的上升子序列有多少 裸的dp是o(n2m) 所以需要优化 我们可以发现dp的第3维是找比它小的数,那么就可以用树状数组来找 这样就可以降低复杂度 #include<iostream> #include<cstdio> #include<cstring> #include

hdu 1207 汉诺塔II (DP+递推)

汉诺塔II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4529    Accepted Submission(s): 2231 Problem Description 经典的汉诺塔问题经常作为一个递归的经典例题存在.可能有人并不知道汉诺塔问题的典故.汉诺塔来源于印度传说的一个故事,上帝创造世界时作了三根金刚石柱子,在一根柱子上从下往

[hdu 2102]bfs+注意INF

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2102 感觉这个题非常水,结果一直WA,最后发现居然是0x3f3f3f3f不够大导致的--把INF改成INF+INF就过了. #include<bits/stdc++.h> using namespace std; bool vis[2][15][15]; char s[2][15][15]; const int INF=0x3f3f3f3f; const int fx[]={0,0,1,-1};

HDU 3555 Bomb (数位DP)

数位dp,主要用来解决统计满足某类特殊关系或有某些特点的区间内的数的个数,它是按位来进行计数统计的,可以保存子状态,速度较快.数位dp做多了后,套路基本上都差不多,关键把要保存的状态给抽象出来,保存下来. 简介: 顾名思义,所谓的数位DP就是按照数字的个,十,百,千--位数进行的DP.数位DP的题目有着非常明显的性质: 询问[l,r]的区间内,有多少的数字满足某个性质 做法根据前缀和的思想,求出[0,l-1]和[0,r]中满足性质的数的个数,然后相减即可. 算法核心: 关于数位DP,貌似写法还是