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

最新推荐文章于 2020-04-29 16:52:38 发布
最新推荐文章于 2020-04-29 16:52:38 发布
阅读量1.7k 收藏 11
点赞数 2
分类专栏： 最短路径 MST 并查集 文章标签： C++ 最短路径 最小生成树 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huahua520amy/article/details/10240657
版权
并查集 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
最短路径
2 篇文章 0 订阅
订阅专栏
MST
2 篇文章 0 订阅
订阅专栏
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】条道路，所有城镇即可连通。
84062722013-05-29 21:57:31Accepted123215MS204K960 BG++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）若当前处理的两个村庄在同一集合中，则不作处理；若当前处理的两个村庄在不同集合中，则建立道路，更新要建设的道路总距离；（判断与合并操作用并查集实现）
90119772013-08-20 10:43:51Accepted1233187MS296K984 BC++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还是畅通工程，只是处理依据不是距离而是经费，不过同理可得。最后有个判断能否全部连通的步骤，直接处理并查集集合根节点记录数组，数下一共有多少个根节点。若根节点不止一个，则表示所有村庄不能全部连通，输出“？”，否则，直接输出费用即可。

90126742013-08-20 11:20:34Accepted18630MS240K1019 BC++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城镇到起始城镇的最小距离。
90410472013-08-23 15:03:37Accepted187415MS396K1097 BC++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，则不予处理。否则，存储结构体数组，待处理。

90437232013-08-23 20:31:22Accepted1875171MS300K1346 BG++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

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


90413602013-08-23 15:33:18Accepted1879375MS296K1014 BC++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;
}


HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，但受益匪浅） 来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得...
HDU+2000-2099+解题报告
08-31
这个压缩包文件“HDU 2000-2099 解题报告”显然包含了在这个题号范围内的一些问题、答案以及解题思路，对于学习算法和提升编程能力具有很高的价值。 在这个范围内，我们可以预见到涵盖的算法类型可能包括但不限于：...
解题报告之——hdu1233还是畅通工程（最小生成树）
Reverie
01-22 600
Description 某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。    Input 测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 当N为0时，
HDU1233 还是畅通工程 解题报告--prim
Lucky
08-03 444
还是畅通工程 Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 19941    Accepted Submission(s): 8846 Problem Description 某省调查乡村交通状况，得到的统计表中列出
hdu 1233 还是畅通工程 解题报告
weixin_30691871的博客
09-08 69
题目链接：http://code.hdu.edu.cn/showproblem.php?pid=1233 并查集的运用， 实质就是求最小生成树。先对所有的村庄距离从小到大排序，然后判断村庄之间是否属于同一集合，不是则将距离相加。属于同一集合，说明村庄连成了环，就不符合树的定义了。这样扫描下来，就求得最小生成树了。 要特别注意的是，数组越界问题。这个得益于Dwylkz的指点。...
HDU各种考试题题解
海岛Blog
04-29 6136
HDU各种考试题题解 浙大计算机研究生复试上机考试-2005年 HDU1228 A + B【map】 - 海岛Blog - CSDN博客 HDU1231 最大连续子序列【最大子段和+DP】_算法,动态规划_海岛Blog-CSDN博客 HDU1232 畅通工程【并查集】_Java_海岛Blog-CSDN博客 HDU1234 开门人和关门人【水题】 - 海岛Blog - CSDN博客 ...
HDU1879 继续畅通工程【Kruskal算法+并查集】
海岛Blog
02-27 2107
继续畅通工程Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 26913    Accepted Submission(s): 11362Problem Description 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通...
HDU - 1863［畅通工程］ 最小生成树Kruskal
Venishel的博客
07-14 482
hdu1863 畅通工程
HDU 1000 A+B Problem
龙少的小窝
04-04 658
HDU OJ 题解目录 A + B Problem Calculate A + B. 　 Input Each line will contain two integers A and B. Process to end of file. 　 Output For each case, output A + B in one line. 　 Sample Input 1 1 　 Sample O...
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
【标题】"HDU_2010.rar"是一个压缩包文件，其中包含了与"HDU 2010"相关的资源，特别是针对"HDU ACM20"比赛的编程题目。"hdu 2010"和"hdu 20"可能是该比赛的不同简称或分类，而"hdu acm20"可能指的是该赛事的第20届...
hdu.rar_hdu
09-23
压缩包内的文件名“朝花夕拾——hdu”可能表示这是一系列关于HDU题目的代码记录，"朝花夕拾"是一个成语，意味着回忆过去的事情，这里可能是暗示这些代码是作者在过去解决HDU题目时留下的，现在整理出来分享或复习。...
hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj
09-24
【标题】"hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj" 提供的信息是关于一个压缩文件，其中包含了一个名为 "HDU 1089.cpp" 的源代码文件，这个文件是为了解决杭州电子科技大学（Hangzhou Dianzi ...
matplotlib-3.6.3-cp39-cp39-linux_armv7l.whl
11-18
matplotlib-3.6.3-cp39-cp39-linux_armv7l.whl
numpy-2.0.1-cp39-cp39-linux_armv7l.whl
11-18
numpy-2.0.1-cp39-cp39-linux_armv7l.whl
基于springboot个人公务员考试管理系统源码数据库文档.zip
最新发布
11-18
基于springboot个人公务员考试管理系统源码数据库文档.zip
onnxruntime-1.13.1-cp310-cp310-win_amd64.whl
11-18
onnxruntime-1.13.1-cp310-cp310-win_amd64.whl
基于springboot的西山区家政服务网站源码数据库文档.zip
11-18
基于springboot的西山区家政服务网站源码数据库文档.zip
Linux环境下，关于C++静态库的封装和调用代码
11-18
Linux环境下，关于C++静态库的封装和调用代码。 TestLib是库目录。 TestLibCall是调用库的目录。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值