畅通工程系列

这道题目求使全省畅通的最低成本，把村庄作为顶点，把道路作为边，那么该题即求最小生成树的总边权值

1.某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？
Input
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。
Output
对每个测试用例，在1行里输出最少还需要建设的道路数目。
Sample Input
4 2
1 3
4 3
3 3
1 2
1 3
2 3
5 2
1 2
3 5
999 0
0

#include<stdio.h>
#include<math.h>
#include<string.h>
int b[1002];
int findx(int x)
{
    int r=x;
    while(b[r]!=r)
        r=b[r];
    return r;
}
void merge(int x,int y)
{
    int fx,fy;
    fx=findx(x);
    fy=findx(y);
    if(fx!=fy)
        b[fx]=fy;
}
int main()
{
  int n,m,i,x,y,k;
  while(scanf("%d",&n)&&n)
  {
      for(i=1;i<=n;i++)
        b[i]=i;
        scanf("%d",&m);
     while(m--)
     {
         scanf("%d %d",&x,&y);
         merge(x,y);
     }
     k=-1;
     for(i=1;i<=n;i++)
     if(b[i]==i)
        k++;
     printf("%d\n",k);
  }
}

2.省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。
Input
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。
Output
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。
Sample Input
3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100
Sample Output
3
?

在这里插入代码片#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=105;

struct road
{
    int b;//起点
    int e;//终点
    int v;//成本
} a[maxn*maxn/2];

int root[maxn];
int n,m;//道路数，村庄数
int ans;//最低成本
int cnt;//要修建的道路数目

void init()
{
    for(int i=0; i<maxn; ++i)
        root[i]=i;
    ans=0;
    cnt=0;
}

bool sort1(road r1,road r2)//按照成本从低到高排序
{
    return r1.v<r2.v;
}

int find_(int x)
{
    if(x==root[x])
        return x;
    else
    {
        root[x]=find_(root[x]);
        return root[x];
    }
}

void kruskal()
{
    init();
    sort(a+1,a+n+1,sort1);
    for(int i=1; i<=n; ++i)
    {
        int fb,fe;//记录两顶点的根结点
        fb=find_(a[i].b);
        fe=find_(a[i].e);
        if(fb!=fe)
        {
            if(fb<fe)
                root[fe]=fb;
            else
                root[fb]=fe;
            ans+=a[i].v;
            cnt++;
            if(cnt==m-1)
                break;
        }
    }
}

int main()
{
    while(cin>>n>>m&&n)
    {
        int i;
        for(i=1; i<=n; ++i)
            cin>>a[i].b>>a[i].e>>a[i].v;
        kruskal();
        if(cnt==m-1)
            cout<<ans<<endl;
        else
            cout<<"?"<<endl;
    }
    return 0;
}

原博主文章
3.省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。
Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。
Output
每个测试用例的输出占一行，输出全省畅通需要的最低成本。
Sample Input
3
1 2 1 0
1 3 2 0
2 3 4 0
3
1 2 1 0
1 3 2 0
2 3 4 1
3
1 2 1 0
1 3 2 1
2 3 4 1
0
Sample Output
3
1
0

在这里插入代码片#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=10015;
struct SS
{
    int a,b,c;
}p[maxn];
bool cmp(SS a,SS b)
{
    return a.c<b.c;
}
int f[1010];
int gets(int x)
{
    if(x!=f[x])
        f[x]=gets(f[x]);
    return f[x];
}
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        int m,i,fx,fy,k=0,t;
        m=n*(n-1)/2;
        for(int i=0;i<=n;i++)
            f[i]=i;
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d %d",&p[i].a,&p[i].b,&p[i].c,&t);
            if(t==1)
                p[i].c=0;
        }
        sort(p,p+m,cmp);
        for(i=0;i<m;i++)
        {
            fx=gets(p[i].a);
            fy=gets(p[i].b);
            if(fx!=fy)
            {
                k+=p[i].c;
                f[fy]=fx;
            }
        }
        printf("%d\n",k);
    }
    return 0;
}

4.某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。
Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。
Output
对每个测试用例，在1行里输出最小的公路总长度。
Sample Input
3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0
Sample Output
3
5

Huge input, scanf is recommended.

在这里插入代码片#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;
int n,par[101];
struct edge
{
    int u,v,s;
}q[5001];

void initial()
{
    for(int i=1;i<=101;i++)
        par[i]=i;;
}
int find(int x)
{
    if(x!=par[x])
        par[x]=find(par[x]);
        return par[x];
}
bool unite(int x,int y)
{
    int  fx=find(x);
    int  fy=find(y);
    if(fx!=fy)
    {
        par[fx]=fy;
        return 1;
    }
    return 0;
}
void kruskal()
{
    int ans=0,u,v;
    int s=0;
    initial();
    for(int i=0;i<n*(n-1)/2;i++)
    {
        u=q[i].u;
        v=q[i].v;
        if(unite(u,v))
            s+=q[i].s;
    }
    printf("%d\n",s);
}
bool cmp(edge a,edge b)
{
    return a.s<b.s;
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        for(int i=0;i<n*(n-1)/2;i++)
            scanf("%d%d%d",&q[i].u,&q[i].v,&q[i].s);
        sort(q,q+n*(n-1)/2,cmp);
        kruskal();
    }
    return 0;
}

5.某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。
Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。
Output
对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.
Sample Input
3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2
Sample Output
2
-1

在这里插入代码片#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=1010;
const int INF=0x3f3f3f3f;
int e[maxn][maxn];
int n,m;
void floyd()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        if(e[i][j]>e[i][k]+e[k][j])
        e[i][j]=e[i][k]+e[k][j];
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(e,INF,sizeof(e));
        int a,b,c;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(e[a][b]>c)
                e[a][b]=e[b][a]=c;
        }
        scanf("%d%d",&a,&b);
        floyd();
        if(a==b)
            printf("0\n");
        else if(e[a][b]<INF)
            printf("%d\n",e[a][b]);
        else
            printf("-1\n");
    }
    return 0;
}