/*
题意：建立n个村庄，实现所有村庄可通，给出村庄两两的距离和已经连通了的村庄，
求连通剩下村庄的最小的总距离
思路：就是求剩下的未连通的村庄的最小生成树，把已经连通了的村庄之间的距离设为0，
这样在最小生成树构建过程中就不参与考虑了。
*/
#include<cstdio>
#include<cstring>
#define INF 0xffffff
int map[105][105];
int visit[105],dis[105],sum,N;
void prim()
{
memset(visit,false,sizeof(visit));
int i,j;
for(i=2;i<=N;i++)
dis[i]=map[1][i];
dis[1]=0;
visit[1]=true;
for(i=1;i<=N;i++)
{
int k,tmp=INF;
for(j=1;j<=N;j++)
if(!visit[j]&&dis[j]<tmp)tmp=dis[k=j];
if(tmp==INF) break;
visit[k]=true;
sum+=dis[k]; //此处多一个记录总权值
for(j=1;j<=N;j++)
{
if(!visit[j]&&dis[j]>map[k][j]) // 此处不同于dijkstra
dis[j]=map[k][j];
}
}
}
int main()
{
int M,i,j;
while(scanf("%d",&N)!=EOF)
{
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
scanf("%d",&map[i][j]);
scanf("%d",&M);
int a,b;
for(i=0;i<M;i++)
{
scanf("%d%d",&a,&b);
map[a][b]=map[b][a]=0;
}
sum=0;
prim();
printf("%d\n",sum);
}
return 0;
}
Eddy's picture
/*
题目大意：
给你一些点的坐标，然后求连通这些点的最小线段的长度。
解题思路：
其实也就是最小生成树的裸题。只不过需要对这n个点全部处理一下，求出每对点之间的长度，
然后存入邻接矩阵。然后就KO了。。
这道题悲剧的地方在于最大值赋值的时候出现了错误，在比赛里提交编译错误，在外面提交就AC了。
问了N个人也没能解决。
原来是最大值越界了。
以后要用#include<climits>里面的INT_MAX来给变量赋最大值。这样就不会出错了，
因为是系统变量。。。。
*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<climits> //INT_MAX的头文件
#include<algorithm>
using namespace std;
#define MAXN 110
double map[MAXN][MAXN], lowcost[MAXN];
bool visit[MAXN];
double sum;
struct point
{
double x, y;
};
point dian[MAXN];
double fun(const point x, const point y)
{
return sqrt((y.y - x.y) * (y.y - x.y) + (y.x - x.x) * (y.x - x.x));
}
void prim(int end)
{
double temp;
int i, j, k;
sum = 0;
memset(visit, false, sizeof(visit));
for(i = 1; i <= end; ++i)
lowcost[i] = map[1][i];
visit[1] = true;
for(i = 1; i <= end; ++i)
{
temp =INT_MAX; //这里错了N久。。以后就这么用了。。。
for(j = 1; j <= end; ++j)
if(!visit[j] && temp > lowcost[j])
temp = lowcost[k = j];
if(temp == INT_MAX)
break;
visit[k] = true;
sum += temp;
for(j = 1; j <= end; ++j)
if(!visit[j] && lowcost[j] > map[k][j])
lowcost[j] = map[k][j];
}
}
int main()
{
int i, j, num, count;
double x, y;
while(scanf("%d", &num) != EOF)
{
count = 0;
for(i = 1; i < MAXN; ++i)
for(j = 1; j < MAXN; ++j)
map[i][j] = INT_MAX;
for(i = 1; i <= num; ++i)
{
count++;
scanf("%lf%lf", &dian[count].x, &dian[count].y);
}
for(i = 1; i <= count; ++i)
for(j = 1; j <= count; ++j)
{
if(j == i) continue;
map[i][j] = min(map[i][j], fun(dian[i], dian[j]));
}
prim(count);
printf("%.2lf\n", sum);
}
return 0;
}
畅通工程
/*
并查集
*/
#include<stdio.h>
const int MAXN=1010;
int F[MAXN];
int find(int t)
{
if(F[t]==-1) return t;
return F[t]=find(F[t]);
}
void bing(int a,int b)
{
int t1=find(a);
int t2=find(b);
if(t1!=t2) F[t1]=t2;
}
int main()
{
int n,m;
while(scanf("%d",&n),n)
{
scanf("%d",&m);
for(int i=1;i<=n;i++) F[i]=-1;
int a,b;
while(m--)
{
scanf("%d%d",&a,&b);
bing(a,b);
}
int res=0;
for(int i=1;i<=n;i++)
if(F[i]==-1) res++;
printf("%d\n",res-1);
}
return 0;
}
还是畅通工程
/*
这道也比较简单，是1232 畅通工程的升级版，不过也比较简单，首先按照所给的路程排序，
然后依次如果不是在一个集合里就合并，并加上所需的路程，最后所得就是所需的最短路程了。
*/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
struct point{
int x,y;
int index;
}num[5008];
int flag[102];
int cmp(const void *a,const void *b)
{
struct point *c,*d;
c=(struct point *)a;
d=(struct point *)b;
return c->index-d->index;
}
int father(int x)
{
if(x==flag[x])
return x;
flag[x]=father(flag[x]);
return flag[x];
}
int main()
{
int n,i,sum,ra,rb;
while(scanf("%d",&n),n)
{
for(i=0;i<=n;i++)
flag[i]=i;
for(i=0;i<n*(n-1)/2;i++)
scanf("%d%d%d",&num[i].x,&num[i].y,&num[i].index);
qsort(num,n*(n-1)/2,sizeof(num[0]),cmp);
sum=0;
for(i=0;i<n*(n-1)/2;i++)
{
ra=father(num[i].x);
rb=father(num[i].y);
if(ra==rb)continue;
else {
sum+=num[i].index;
if(ra<rb)
flag[rb]=ra;
else flag[ra]=rb;
}
}
printf("%d\n",sum);
}
return 0;
}
继续畅通工程
/*
只是需要判断一下修过没有罢了，修过的我们不妨默认为所需的金额为0
*/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
struct point{
int x,y;
int index;
}num[5008];
int flag[102];
int cmp(const void *a,const void *b)
{
struct point *c,*d;
c=(struct point *)a;
d=(struct point *)b;
return c->index-d->index;
}
int father(int x)
{
if(x==flag[x])
return x;
flag[x]=father(flag[x]);
return flag[x];
}
int main()
{
int n,i,sum,ra,rb,c,d;
while(scanf("%d",&n),n)
{
for(i=0;i<=n;i++)
flag[i]=i;
for(i=0;i<n*(n-1)/2;i++)
{
scanf("%d%d%d%d",&num[i].x,&num[i].y,&c,&d);
if(d==1)num[i].index=0;
else num[i].index=c;
}
qsort(num,n*(n-1)/2,sizeof(num[0]),cmp);
sum=0;
for(i=0;i<n*(n-1)/2;i++)
{
ra=father(num[i].x);
rb=father(num[i].y);
if(ra==rb)continue;
else {
sum+=num[i].index;
if(ra<rb)
flag[rb]=ra;
else flag[ra]=rb;
}
}
printf("%d\n",sum);
}
return 0;
}
Jungle Roads
/*
通过对数组构造一个静态链表，将在同一个连通分量中的顶点链接起来。
对按边权值从大到小排序后的边集合逐条进行判断，
若边的起点和终点分别在不同的连通分量链表中
（这通过获取其所在链表的表尾元素是否是同一个来进行判定），
则此边加入最小生成树的边集合中，并将边的终点加入到边的起点所在的静态链表中。
最终所有结点都会链接到一个静态链表中。
*/
#include<iostream>
#include<string>
#include<algorithm>
using namespace std ;
const int MAX_VETEXT_NUM = 26;//最大的顶点数
const int MAX_EDGE_NUM = 75;//最大的边数
struct Edge
{
int begin;//起点
int end;//结点
double cost;//边的权值
};
Edge edge[MAX_EDGE_NUM];//边集合
double sum = 0;
int ConnectedList[MAX_VETEXT_NUM];//连通分量静态链表
int nEdges; //边的数目
int nVetexs; //顶点数目
int FindInConnectList( int Point[] , int v)
{//若v所在的连通分量静态链表为空，则返回参数v,否则返回其所在链表的表尾元素,
int i = v ;
while ( Point[i] > 0 )
i = Point[i];
return i ;
}
bool cmp( const Edge& a , const Edge& b )
{//根据边权值从小到大排序
return a.cost < b.cost ;
}
void Kruscal()
{
int i , j ;
int v1 , v2 ;
//初始化连通分量静态链表
for ( i = 0 ; i < nVetexs ; i++ )
{
ConnectedList[i] = 0 ;
}
i = 0 ; j = 0 ;
while ( j < nVetexs - 1 && i < nEdges )
{
v1 = FindInConnectList( ConnectedList , edge[i].begin) ;
v2 = FindInConnectList( ConnectedList , edge[i].end) ;
if ( v1 != v2)
{//起点和终点不在同一个连通分量重
sum += edge[i].cost;
ConnectedList[v1] = v2 ;//加入连通分量链表中
++j;//最小生成树边数加1
}
++i;//处理完一条边
}
}
int main()
{
int i , j ;
int num ;
double cost ;
char chStart , chEnd;
while ( cin >> nVetexs && nVetexs != 0)
{
sum = 0 ;
nEdges = 0 ;
for ( i = 0 ; i < nVetexs - 1 ; i ++ )
{
cin >> chStart >> num ;
for( j = 0 ; j < num ; j ++ )
{
cin >> chEnd >> cost ;
edge[nEdges].begin = chStart - 'A' ;
edge[nEdges].end = chEnd - 'A' ;
edge[nEdges].cost = cost ;
nEdges ++;
}
}
sort(edge , edge + nEdges, cmp) ;
Kruscal() ;
cout << sum << endl ;
}
return 0 ;
}
Connect the Cities
/*
最小生成树、就是把已经连接的边权值设为0
*/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <cmath>
#include <queue>
#define N 503
using namespace std;
int map[N][N];
bool b[N];
int n;
void prim()
{
memset(b,0,sizeof(b));
b[1]=1;
int i,j,t=n,min,sum=0;
while(--t)
{ min=1000;
for(i=2;i<=n;i++)
if(!b[i]&&map[1][i]<min)
min=map[1][i],j=i;
if(min==1000) break;
b[j]=1;
sum+=min;
for(i=2;i<=n;i++)
if(!b[i]&&map[1][i]>map[j][i])
map[1][i]=map[j][i];
}
if(min==1000)
printf("-1\n");
else
printf("%d\n",sum);
}
int main()
{
int m,l,k,t,T,i,j;
scanf("%d",&T);
while(T--)
{
scanf("%d%d%d",&n,&m,&l);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
map[i][j]=1000;
while(m--)
{
scanf("%d%d%d",&i,&j,&k);
map[i][j]=map[i][j]>k?k:map[i][j];
map[j][i]=map[i][j];
}
while(l--)
{
scanf("%d%d",&t,&i);
while(--t)
{
scanf("%d",&j);
map[i][j]=map[j][i]=0;
i=j;
}
}
prim();
}
return 0;
}
Pseudoforest
/*
合并的时候分情况，是否两个都有环，其中一个有环，两个都没有环
*/
#include<iostream>
using namespace std;
#include<algorithm>
#define N 10001
#define M 100001
int bin[N];
bool flag[N];
struct node{
int x,y;
int w;
}p[M];
void init(int n){
for(int i=0;i<=n;i++)
bin[i]=i;
memset(flag,0,sizeof(flag));
}
int find(int x){
if(bin[x]==x)
return bin[x];
return bin[x]=find(bin[x]);
}
bool merge(int x,int y){
int fx=find(x);
int fy=find(y);
if(fx==fy){
if(!flag[fx]){
flag[fx]=1;
return true;
}
return false;
}
if(flag[fx]&&flag[fy])
return false;
if(flag[fx])
bin[fy]=fx;
else
bin[fx]=fy;
return true;
}
bool cmp(node a,node b){
return a.w>b.w;
}
int main(void){
int n,m;
while(scanf("%d%d",&n,&m),n||m){
init(n);
for(int i=0;i<m;i++)
scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].w);
sort(p,p+m,cmp);
int ans=0;
for(int i=0;i<m;i++)
if(merge(p[i].x,p[i].y))
ans+=p[i].w;
printf("%d\n",ans);
}
}
1323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
