(最小生成树)hdu 3371

Connect the Cities

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

Problem Description

In 2100, since the sea level rise, most of the cities disappear. Though some survived cities are still connected with others, but most of them become disconnected. The government wants to build some roads to connect all of these cities again, but they don’t want to take too much money.

Input

The first line contains the number of test cases.
Each test case starts with three integers: n, m and k. n (3 <= n <=500) stands for the number of survived cities, m (0 <= m <= 25000) stands for the number of roads you can choose to connect the cities and k (0 <= k <= 100) stands for the number of still connected cities.
To make it easy, the cities are signed from 1 to n.
Then follow m lines, each contains three integers p, q and c (0 <= c <= 1000), means it takes c to connect p and q.
Then follow k lines, each line starts with an integer t (2 <= t <= n) stands for the number of this connected cities. Then t integers follow stands for the id of these cities.

Output

For each case, output the least money you need to take, if it’s impossible, just output -1.

Sample Input

1
6 4 3
1 4 2
2 6 1
2 3 5
3 4 33
2 1 2
2 1 3
3 4 5 6

Sample Output

1

Author

dandelion

有些边已经联通,有些边还未联通。。。

不知道为嘛超时啊啊啊啊啊啊啊啊啊啊啊啊啊

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<vector>
using namespace std;
struct node
{
    int x,y,w;
}e[25005];
int n,m,k,cnt,fa[25005];
/*
int find(int x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}
*/
int find(int x)
{
    while(x!=fa[x])
        x=fa[x];
    return fa[x];
}
int Union(int x,int y)
{
    if(x==-1)
        return 0;
    int fx,fy;
    bool flag=false;
    fx=find(x),fy=find(y);
    if(fx!=fy)
    {
        --cnt;
        fa[fx]=fy;
        flag=1;
    }
    return flag;
}
bool cmp(node a,node b)
{
    return a.w<b.w;
}
int main()
{
    int tt;
    scanf("%d",&tt);
    while(tt--)
    {
        int ans=0;
        scanf("%d%d%d",&n,&m,&k);
        cnt=n-1;
        for(int i=0;i<=n;i++)
            fa[i]=i;
        for(int i=1;i<=m;i++)
            scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].w);
        for(int i=0;i<k;i++)
        {
            int a,c,pre=-1;
            scanf("%d",&a);
            while(a--)
            {
                scanf("%d",&c);
                Union(pre,c);
                pre=c;
            }
        }
        sort(e+1,e+1+m,cmp);
        for(int i=1;i<=m;i++)
        {
            if(Union(e[i].x,e[i].y)==1)
                ans+=e[i].w;
        }
        if(cnt!=0)
            printf("-1\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}

  

时间: 2024-10-06 10:55:53

(最小生成树)hdu 3371的相关文章

hdu 3371 最小生成树prim算法

Connect the Cities Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 8992    Accepted Submission(s): 2519 Problem Description In 2100, since the sea level rise, most of the cities disappear. Thoug

hdu 3371 Connect the Cities

链接:hdu 3371 已知已连通的路的序号,以及未连通的路的费用,求将所有城市连通的最小费用 也是将已连通的路的费用记为0,就转化成了基本最小生成树的题 不过这题数组要开的大点,不然很容易就RE了... #include<cstdio> #include<algorithm> using namespace std; int f[510],n,m; struct stu { int a,b,c; }t[100000]; int cmp(struct stu x,struct st

Hdu 3371 Connect the Cities(最小生成树)

地址:http://acm.hdu.edu.cn/showproblem.php?pid=3371 其实就是最小生成树,但是这其中有值得注意的地方:就是重边.题目没有告诉你两个城市之间只有一条路可走,所以两个城市之间可能有多条路可以走. 举例: 输入可以包含 1 2 3  // 1到2的成本为3   1 2 5  //1到2的成本为5      因此此时应选成本较低的路. 然后,已经连通的城市之间的连通成本为0. 这题用G++提交得到984ms的反馈,用C++提交则得到484ms的反馈. 很想知

HDU 3371 Connect the Cities 【最小生成树,Prime算法+Kruskal算法】

Connect the Cities Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 17167    Accepted Submission(s): 4335 Problem Description In 2100, since the sea level rise, most of the cities disappear. Tho

hdu 3371 最小生成树 prim

http://acm.hdu.edu.cn/showproblem.php?pid=3371 题目大意:告诉你有几座城市,再告诉你哪两座城市之间建路要多少钱,在给你哪几个城市之间已经有路,不需要再建.要求的是要使所有城市之间连通最小要花费多少钱. 这里我用了prim算法..保存城市之间的权值,对于已经建好的城市,将他们的权值赋为0.还有就是要判断是否能找出最小生成树,如果不可以就输出-1,如果在遍历点的时候,并不能找出一个最小的边,那么肯定就是没有最小生成树.(注意要在每个kase开始的时候将所

hdu 3371 Connect the Cities (最小生成树Prim)

题目连接:http://acm.hdu.edu.cn/showproblem.php?pid=3371 题目不难 稍微注意一下 要把已经建好的城市之间的花费定义为0,在用普通Prim算法就可以了:我没有用克鲁斯卡尔算法(Kruskal's algorithm),因为这题数据比较大,而且要处理大量的数据使它为0,怕超时T^T..... 1 #include<iostream> 2 #include<cstdio> 3 #include<algorithm> 4 5 usi

hdu 3371 最小生成树

深夜来一发,裸的最小生成树,数据量还挺大,kruskal算法g++始终过不去,c++刚好飘过,这个时候就体现出kruskal和prim的适用范围的不同了,前者适用于稀疏图,后者适用于稠密图. kruskal算法: 1 #include <stdio.h> 2 #include <algorithm> 3 using namespace std; 4 5 const int N = 501; 6 const int M = 25000; 7 int f[N]; 8 int buffe

hdu 3371(Connect the Cities)(最小生成树)

Connect the Cities Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 10692    Accepted Submission(s): 3037 Problem Description In 2100, since the sea level rise, most of the cities disappear. Tho

HDU 3371 kruscal/prim求最小生成树 Connect the Cities 大坑大坑

这个时间短 700多s #include<stdio.h> #include<string.h> #include<iostream> #include<algorithm> using namespace std; struct node{ int u; int v; int w; }que[100000]; int father[505]; bool cmp(struct node a,struct node b){ return a.w<b.w;

hdu 3371 Connect the Cities 最小生成树

#include <stdio.h> #include <string.h> #include <iostream> #include <algorithm> #include <vector> #include <queue> #include <stack> #include <set> #include <map> #include <string> #include <ma