畅通工程 并查集，最小生成树，最短路径

转载此大佬的博客

http://blog.csdn.net/juanlansexuehua/article/details/63271701

一、题目列表：
1、HDU1232畅通工程
2、HDU1233还是畅通工程
3、HDU1863畅通工程
4、HDU1874畅通工程续
5、HDU1875畅通工程再续
6、HDU1879继续畅通工程

二、主要考点：图论基础（并查集，最小生成树，最短路径）
三、解题报告：

畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 51259    Accepted Submission(s): 27325

Problem Description

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

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

Sample Output

1 0 2 998

基本思路：很明显是使用并查集的方法（基本就是套的它的模板就行了）

已经AC过的代码：

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int n,m,x,y;
int arr[10005];
int getf(int v)
{
    if(arr[v]==v)
        return v;
    else
    {
        arr[v]=getf(arr[v]);
        return arr[v];
    }
}
int merg(int v,int u)
{
    int t1,t2;
    t1=getf(v);
    t2=getf(u);
    if(t1!=t2)
    {
        arr[t2]=t1;
    }
    return 0;
}

int main()
{
    while(scanf("%d %d",&n,&m)&&n)
    {
        int sum=0;
        memset(arr,0,sizeof(arr));
        for(int i=1; i<=n; i++)
        {
            arr[i]=i;
        }
        for(int i=1; i<=m; i++)
        {
            scanf("%d %d",&x,&y);
            merg(x,y);
        }
        for(int i=1; i<=n; i++)
        {
            if(arr[i]==i)
                sum++;
        }
        printf("%d ",sum-1);
    }
    return 0;
}

畅通工程

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 27832    Accepted Submission(s): 12212

Problem Description

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

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 ?

 

基本思路：（依然是个并查集的裸题，可以直接套用它的模板，但是要注意如果数据的话，输出？）

已经AC过的代码：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const int Infinity=9999999;
const int maxNum=105;

int map[maxNum][maxNum];
bool visited[maxNum];//标志点是否入已经集合
int low[maxNum],nodeNum;//结点

int prim()
{
    int result,i,j,min,pos=1;//pos=1表示从点1开始
    memset(visited,0,sizeof(visited));

    result=0;

    for(i=1; i<=nodeNum; i++)
        low[i]=map[pos][i];

    visited[pos]=1;

    for(i=1; i<nodeNum; i++)
    {
        min=Infinity,pos=-1;

        for(j=1; j<=nodeNum; j++)
            if(!visited[j]&&min>low[j])
            {
                min=low[j];
                pos=j;
            }
        if(pos==-1)//如果pos等于-1，证明没有点可以入集，那么最下生成树不能完成
            return -1;
        visited[pos]=1;//pos点标志掉
        result+=min;

        for(j=1; j<=nodeNum; j++)
            if(!visited[j]&&low[j]>map[pos][j])
                low[j]=map[pos][j];//这里的j写成了i,擦，改了半个小时，真得困了
    }
    //cout<<"result_is "<<result<<endl;
    return result;
}

int main(void)
{
    int n,s,e,w,i,j,ans;
    while(scanf("%d%d",&n,&nodeNum),n)//边，结点数
    {
        for(i=1; i<=nodeNum; i++)
            for(j=1; j<=nodeNum; j++)
            {
                map[i][j]=Infinity;
            }
        for(i=1; i<=n; i++)
        {
            scanf("%d%d%d",&s,&e,&w);
            if(map[s][e]>w)//注意这里可能有重边
                map[s][e]=map[e][s]=w;
        }

        ans=prim();

        if(ans==-1)
            cout<<"?"<<endl;
        else
            cout<<ans<<endl;
    }
    return 0;
}

1874 畅通工程续

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 50637    Accepted Submission(s): 18888

Problem Description

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

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

 

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

 

已经AC过的代码：Dijkstra算法

 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=210;
int n,m,s,t;
int map[N][N],dis[N],vis[N];
void Dijkstra(int src)
{
    int i;
    for(i=0; i<n; i++)
    {
        dis[i]=map[src][i];
        vis[i]=0;
    }
    dis[src]=0;
    vis[src]=1;
    int j,k,tmp;
    for(i=0; i<n; i++)
    {
        tmp=INF;
        for(j=0; j<n; j++)
            if(!vis[j] && tmp>dis[j])
            {
                k=j;
                tmp=dis[j];
            }
        if(tmp==INF)
            break;
        vis[k]=1;
        for(j=0; j<n; j++)
            if(!vis[j] && dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int u,v,w;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                map[i][j]=INF;
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(map[u][v]>w)
                map[u][v]=map[v][u]=w;
        }
        scanf("%d%d",&s,&t);
        Dijkstra(s);
        if(dis[t]==INF)
            printf("-1 ");
        else
            printf("%d ",dis[t]);
    }
    return 0;
}

 

 

1875 畅通工程再续

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

Problem Description

 

相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元/米。

Input

输入包括多组数据。输入首先包括一个整数T(T <= 200)，代表有T组数据。
每组数据首先是一个整数C(C <= 100),代表小岛的个数，接下来是C组坐标，代表每个小岛的坐标，这些坐标都是 0 <= x, y <= 1000的整数。

Output

每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh!”.

Sample Input

2 2 10 10 20 20 3 1 1 2 2 1000 1000

Sample Output

1414.2 oh!

已经AC过的代码：

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
struct Island
{
    int x,y;
};
struct node
{
    int u,v;
    double w;
};
Island arr[220];
node  edge[20000];
int per[220];
int n;
bool cmp(node a,node b)
{
    return a.w<b.w;
}
void init()
{
    for(int i=1; i<=n; ++i)
    {
        per[i]=i;
    }
}
int find(int x)
{
    if(x==per[x]) return x;
    return per[x]=find(per[x]);
}
bool join(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
    {
        per[fx]=fy;
        return 1;
    }
    return 0;
}
int main()
{
    int T;
    int i,j,k;
    double x,y;
    scanf("%d",&T);
    while(T--)
    {

        scanf("%d",&n);
        init();
        for(i=1; i<=n; ++i)
        {
            scanf("%d%d",&arr[i].x,&arr[i].y);
        }
        //m=n*(n-1)/2;
        k=0;
        for(i=1; i<=n; ++i)
        {
            for(j=i+1; j<=n; ++j)
            {
                edge[k].u=i;
                edge[k].v=j;
                x=(arr[j].y-arr[i].y)*(arr[j].y-arr[i].y);
                y=(arr[j].x-arr[i].x)*(arr[j].x-arr[i].x);
                double temp=sqrt(x+y);
                edge[k++].w=temp;
            }
        }
        sort(edge,edge+k,cmp);
        double sum=0;
        for(i=0; i<k; ++i)
        {
            if(edge[i].w<=1000&&edge[i].w>=10&&join(edge[i].u,edge[i].v))//如果两个岛的距离不符合要求就会把join(edge[i].u,edge[i].v）短路
            {
                sum+=edge[i].w;
            }
        }
        int cnt=0;
        bool flag=0;
        for(i=1; i<=n; ++i)
        {
            if(i==per[i]) cnt++;
            if(cnt>1)
            {
                flag=1;
                break;
            }
        }
        if(flag) printf("oh! ");
        else
            printf("%.1lf ",sum*100);
    }
    return 0;
}

 1879 继续畅通工程

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

Problem Description

 

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

 

 

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

 

 

已经AC过的代码：

这道题就是一个简单的Krusal 算法的应用，直接套个模板就可以出来了，就不做详细的解释了

 

 

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define N 10005
using namespace std;
struct node
{
       int a,b;
       int cost,flag;
}s[N];
int f[N];
bool cmp(node A,node B)
{
     if(A.flag != B.flag) return A.flag > B.flag;
     return A.cost < B.cost;
}
int find(int x)
{
    return x == f[x] ? x:f[x] = find(f[x]);
}
int kruskal(int n)
{
    int x,y,sum = 0;
    for(int i = 0; i < n; i++)
    {
          x = find(s[i].a);
          y = find(s[i].b);
          if(x != y)
          {
               f[x] = y;
               if(s[i].flag == 0)
                    sum += s[i].cost;
          }
    }
    return sum;
}
int main()
{
     int n;
     while(scanf("%d",&n) && n)
     {
          int i,j;
          int m = n*(n-1)/2;
          for(i = 0; i < m; i++)
                scanf("%d%d%d%d",&s[i].a,&s[i].b,&s[i].cost,&s[i].flag);
          sort(s,s+m,cmp);
          for(i = 1; i <= n; i++)
                f[i] = i;
        printf("%d ",kruskal(m));
     }
     return 0;
}

#include <iostream>
using namespace std;
#include<string.h>
#include<set>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include <cstdio>
#include <cstdlib>
#include<cstring>
struct lll
{
     int x,y;
     int len;
}s;
int a[10000];
int find (int n)
{
    if(a[n]==n)
        return n;
    else
        return a[n]=find(a[n]);
}
int chazhao(int n,int m)
{
    int n1=find(n);
    int m1=find(m);
    if(m1==n1)
        return 1;
    else
    {
        a[m1]=n1;
        return 0;
    }
}
struct cmp1{
    bool operator ()(lll &a,lll &b){
        return a.len>b.len;
    }
};
int main()
{
    int t;
    while(scanf("%d",&t),t)
    {
        priority_queue<lll,vector<lll>,cmp1>TM;
        int sum=0;
        int p;
        memset(a,0,sizeof(a));
        for(int i=1;i<=t;i++)
            a[i]=i;
            int temp=t*(t-1)/2;
        for(int i=0;i<temp;i++)
        {
            scanf("%d %d %d %d",&s.x,&s.y,&s.len,&p);
            if(p)
                chazhao(s.x,s.y);
            else
                TM.push(s);
        }
        while(!TM.empty())
        {
            if(chazhao(TM.top().x,TM.top().y)==0)
            {
                sum+=TM.top().len;
            }
            TM.pop();
            int add=0;
            for(int i=1;i<=t;i++)
            {
                if(a[i]==i)
                    {
                        add++;
                    }
            }
            if(add==1)
                break;
        }
        printf("%d
",sum);
    }
    return 0;
}