HDU 畅通工程系列题目解题报告 （HDU1232+HDU1233+HDU1863+HDU1874+HDU1875+HDU1879）

HDU 畅通工程系列题目解题报告

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

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

三、解题报告：


1、HDU1232畅通工程

http://acm.hdu.edu.cn/showproblem.php?pid=1232

该题考点：并查集
并查集基础题，只要求出有几个不连通的集合即可， 建设【独立集合个数-1】条道路 即可将所有不连通集合连通，做到城镇通。
解题算法处理步骤（并查集处理）：
（1）先设每个城镇都是独立的，在一个独立的集合里面，根节点是自身；
（2）对每条建立好的道路，将道路两端的两个城镇所在集合合并（城镇连通）；
（3）对所有的村庄的根节点进行整理，统一同一集合的根节点；
（4）统计根节点种数（独立集合的个数）；
（5）建立建设【独立集合个数-1】条道路，所有城镇即可连通。

8406272

2013-05-29 21:57:31

Accepted

1232

15MS

204K

960 B

G++

try it

AC代码：

#include<stdio.h>
#include<string.h>
int town[1002];
int n,m;
int find(int x)  //寻找根节点
{
    while(x != town[x])  //若x节点为根节点，则有town[x]=x
        x = town[x];
    return x;
}
void union1(int a,int b)   //将a节点所在集合和b节点所在集合合并，根节点相同的集合为同一集合
{
    int a_f=find(a),b_f=find(b);
    if(a_f!=b_f)
        town[b_f]=a_f;
}
int main()
{
    int i,j,k;
    int a,b;
    int sum[1002];
    while(scanf("%d",&n)&&n)
    {
        memset(town,0,sizeof(town[0])*(n+1));   //初始化
        memset(sum,0,sizeof(sum[0])*(n+1));
        for(i=1;i<=n;i++)   //在不知道道路修建情况前，任何城镇都是一个独立的集合
            town[i]=i;
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d",&a,&b);
            union1(a,b);  //将连通的城镇合并到同一集合
        }
        for(i=1; i<=n; i++)   //将所有的集合整理一下，所有在统一同一集合的根节点
            town[i] = find(town[i]);
        for(i=1;i<=n;i++)   //统计所有的根节点
            sum[town[i]]=1;
        int x=0;
        for(i=1;i<=n;i++)   //计算根节点的个数，即不连通集合的个数
            x+=sum[i];
        printf("%d\n",x-1);  //需将所有集合连通，要建【独立集合个数-1】条道路
    }
    return 0;
}

2、HDU1233还是畅通工程

http://acm.hdu.edu.cn/showproblem.php?pid=1233

本题考点：并查集，最小生成树（克鲁斯卡尔算法）
最小生成树基础题，直接用克鲁斯卡算法水过。
解题算法处理步骤（克鲁斯卡尔算法）：
（1）输入并用结构体存储所有两个村庄间的距离情况（编号较小村庄，编号较大村庄，两村庄间的距离）；
（2）对村庄间距离情况进行排序，按距离从小到大的顺序排序；
（3）按距离从小到大对所有两村庄间道路建设情况依次进行处理；
（4）若当前处理的两个村庄在同一集合中，则不作处理；若当前处理的两个村庄在不同集合中，则建立道路，更新要建设的道路总距离；（判断与合并操作用并查集实现）

9011977

2013-08-20 10:43:51

Accepted

1233

187MS

296K

984 B

C++

try it

AC代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
int a[100];  //存储100个节点的根节点
struct node   //道路情况
{
    int x;    //起点
    int y;    //终点
    int dic;   //距离
}road[10000];
bool cmp(node a,node b)  //按距离从小到大排序
{
    return a.dic<b.dic;
}
int father(int x)  //寻找x节点的根节点
{
    while(x!=a[x])x=a[x];
    return x;
}
int main()
{
    int n,m;
    int i,j;
    int sum;
    while(scanf("%d",&n)&&n)
    {
        m=n*(n-1)/2;   //道路条数
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&road[i].x,&road[i].y,&road[i].dic);  //每条道路的情况
            if(road[i].x>road[i].y)swap(road[i].x,road[i].y);   //要求道路起始于编号较小的村庄
        }
        sort(road,road+m,cmp);   //按道路长度从小到大排序
        for(i=0;i<=n;i++)a[i]=i;   //处理前，每个村庄都是独立未连通的
        j=0;
        sum=0;
        for(i=0;i<m&&j<n;i++)   //遍历每一条道路（按道路长度从小到大顺序）
        {
            int x_f=father(road[i].x);  //找出道路两端的两个村庄所在集合的根节点
            int y_f=father(road[i].y);
            if(x_f!=y_f)   //要是道路两端的两个村庄不在同一集合，则建设这条路，合并两个村庄所在集合
            {
                sum+=road[i].dic;   //建设的道路的总长度增加
                j++;
                a[y_f]=x_f;  //合并集合
            }
        }
        printf("%d\n",sum);
    }
    return 0;
}

3、HDU1863畅通工程

http://acm.hdu.edu.cn/showproblem.php?pid=1863

本题考点：并查集，最小生成树（ 克鲁斯卡算法）
基本算法解题思路同2、HDU1233还是畅通工程，只是处理依据不是距离而是经费，不过同理可得。最后有个判断能否全部连通的步骤，直接处理并查集集合根节点记录数组，数下一共有多少个根节点。若根节点不止一个，则表示所有村庄不能全部连通，输出“？”，否则，直接输出费用即可。

9012674

2013-08-20 11:20:34

Accepted

1863

0MS

240K

1019 B

C++

try it

AC代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
int a[100];
struct node
{
    int x;
    int y;
    int dic;
}road[10000];
bool cmp(node a,node b)
{
    return a.dic<b.dic;
}
int father(int x)
{
    while(x!=a[x])x=a[x];
    return x;
}
int main()
{
    int n,m;
    int i,j;
    int sum;
    while(scanf("%d%d",&m,&n)&&m)
    {
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&road[i].x,&road[i].y,&road[i].dic);
            if(road[i].x>road[i].y)swap(road[i].x,road[i].y);
        }
        sort(road,road+m,cmp);
        for(i=0;i<=n;i++)a[i]=i;
        j=0;
        sum=0;
        for(i=0;i<m;i++)
        {
            int x_f=father(road[i].x);
            int y_f=father(road[i].y);
            if(x_f!=y_f)
            {
                sum+=road[i].dic;
                a[y_f]=x_f;
            }
        }
        for(i=1;i<=n;i++)if(a[i]==i)j++;
        if(j==1)printf("%d\n",sum);
        else printf("?\n");
    }
    return 0;
}

4、HDU1874畅通工程续

http://acm.hdu.edu.cn/showproblem.php?pid=1874

本题考点：最短路径（迪杰斯特拉算法）
本题为最短路径基础题，直接用迪杰斯特拉算法水过。
解题算法处理步骤：（迪杰斯特拉算法）
（1）初始化地图，map[i][j]记录城镇i，j之间最短的道路的长度，若无道路连通，则赋为极大值；
（2）又起始城镇开始，用广度优先搜索思想，嵌入松弛处理算法，用dis[i]记录起始城镇到城镇i的最短路径的长度；
（3）答案位于dis[t]，即终点t城镇到起始城镇的最小距离。

9041047

2013-08-23 15:03:37

Accepted

1874

15MS

396K

1097 B

C++

try it

AC代码：

#include<stdio.h>
#include<queue>
using namespace std;

int main()
{
    int n,m;
    int map[200][200];  //map[i][j]记录城镇i到j间最短连通道路长度
    int s,t;  //记录起始村庄和终点村庄编号

    int dis[200];  //dis[i]记录i号村庄到起始村庄的最短的路径长度
    int x,y,d;
    int i,j;

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=0;i<n;i++)
        for(j=0;j<n;j++)map[i][j]=0xfffffff;  //所有路径清理初始化为最大值，便于两城镇间最短的道路的记录更新

        while(m--)
        {
            scanf("%d%d%d",&x,&y,&d);
            if(map[x][y]>d)map[x][y]=d,map[y][x]=d;  //若当前输入道路信息为城镇x,y间长度最短的道路，则更新地图
        }
        scanf("%d%d",&s,&t);

        queue<int> q;
        q.push(s);  //起点入队
        for(i=0;i<n;i++)dis[i]=0xfffffff;   //所有城镇到起始城镇的距离初始化为最大值
        dis[s]=0;  //起始城镇到其自身的距离为0

        while(!q.empty())   //所有与起始城镇连接的城镇都遍历完时，结束遍历
        {
            x=q.front();
            q.pop();
            for(i=0;i<n;i++)
            {
                if(map[x][i]!=0xfffffff)
                {
                    if(dis[i]>dis[x]+map[x][i])   // 从城镇x到城镇i的路径（到起始城镇）较短
                    {
                        dis[i]=dis[x]+map[x][i];   //更新i城镇到起始城镇的最短距离
                        q.push(i);
                    }
                }
            }
        }
        if(dis[t]==0xfffffff)printf("-1\n");  //若起始城镇无法到达终点城镇，输出-1
        else printf("%d\n",dis[t]);
    }
    return 0;
}

5、HDU1875畅通工程再续

http://acm.hdu.edu.cn/showproblem.php?pid=1875

本题考点：两点间距离计算，并查集，最小生成树（克鲁斯卡尔）
基本算法解题思路同 2、HDU1233还是畅通工程，只是道路情况要自己处理，对所有的岛屿，求出两两之间的距离情况，要是距离小于10或大于1000，则不予处理。否则，存储结构体数组，待处理。

9043723

2013-08-23 20:31:22

Accepted

1875

171MS

300K

1346 B

G++

try it

AC代码：

#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
struct node
{
    int x;
    int y;
    double d;
}road[10000];
int is[102];
bool cmp(node a,node b)
{
    return a.d<b.d;
}
int find(int x)
{
    while(is[x]!=x)x=is[x];
    return x;
}
int main()
{
    int n,m,t;
    int x[102],y[102];
    double dis,sum;
    int i,j;
    scanf("%d",&t);
    while(t--)
    {
        m=0;
        sum=0;
        scanf("%d",&n);
        for(i=0;i<n;i++)scanf("%d%d",&x[i],&y[i]);
        for(i=0;i<n;i++)
        for(j=i+1;j<n;j++)
        {
            dis=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
            if(dis>=10&&dis<=1000)
            {
                road[m].x=i;
                road[m].y=j;
                road[m].d=dis;
                m++;
            }
        }
        for(i=0;i<n;i++)is[i]=i;
        sort(road,road+m,cmp);
        for(i=0;i<m;i++)
        {
            int x_f=find(road[i].x);
            int y_f=find(road[i].y);
            if(x_f!=y_f)
            {
                is[y_f]=x_f;
                sum+=road[i].d;
            }
        }
        sum*=100;
        j=0;
        for(i=0;i<n;i++)
            if(is[i]==i)j++;
        if(j==1)printf("%.1lf\n",sum);
        else printf("oh!\n");
    }
    return 0;
}

6、HDU1879继续畅通工程

http://acm.hdu.edu.cn/showproblem.php?pid=1879

本题考点：并查集，最小生成树（克鲁斯卡尔算法）

9041360

2013-08-23 15:33:18

Accepted

1879

375MS

296K

1014 B

C++

try it

AC代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
struct node
{
    int x;
    int y;
    int d;
}road[10000];
int cont[102];
bool cmp(node a,node b)
{
    return a.d<b.d;
}
int find(int x)
{
    while(x!=cont[x])x=cont[x];
    return x;
}
int main()
{
    int n,m;
    int sum,v;
    int i,j;
    while(scanf("%d",&n)&&n)
    {
        m=n*(n-1)/2;
        j=0;
        for(i=0;i<=n;i++)cont[i]=i;
        while(m--)
        {
            scanf("%d%d%d%d",&road[j].x,&road[j].y,&road[j].d,&v);
            if(road[i].x>road[i].y)swap(road[i].x,road[i].y);
            if(v)cont[find(road[j].y)]=find(road[j].x);
            else j++;
        }
        sort(road,road+j,cmp);
        for(i=n;i>=1;i--)cont[i]=find(i);
        sum=0;
        for(i=0;i<j;i++)
        {
            int x_f=find(road[i].x);
            int y_f=find(road[i].y);
            if(x_f!=y_f)cont[y_f]=x_f,sum+=road[i].d;
        }
        printf("%d\n",sum);
    }
    return 0;
}