图论

于 2016-06-26 08:50:02 发布
阅读量391 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_cx/article/details/51761347
版权

出错信息

Accepted（答案正确） ： 你的程序对所有的测试数据都输出了正确的答案，你已经得到了该题的所有分数，恭喜。

Wrong Answer（答案错误） ：评判系统测试到你的程序对若干组（或者全部）测试数据没有输出正确的结果。
出现该种错误后，一般有两种解决方向：如果对设计的算法正确性有较大的把握，那么你可以重点考虑代码健壮性，即是否存在某些特殊数据使程序出现错误，比如边界数据，比如程序中变量出现溢出。另一种方向，即怀疑算法本身的正确性，那么你就需要重新考虑你的算法设计了。

Presentation Error （格式错误） ：评判系统认为你的程序输出“好像”是正确的，只是没有严格按照题目当中输出所要求的输出格式来输出你的答案，例如你忽略了题目要求在每组输出后再输出一个空行。

Time Limit Exceeded （超出时间限制） ：你的程序在输出所有需要输出的答案之前已经超过了题目中所规定的时间。
若这种结果出现在你的评判结果里，依然有两种方向可供参考： 1、假如你确定算法时间复杂度能够符合题目的要求，那么依旧可以检查是否程序可能在某种情况下出现死循环，是否有边界数据可能会让你的代码不按照预想的工作，从而使程序不能正常的结束。 2、你设计的算法时间复杂度是否已经高于题目对复杂度的要求，如果是这样，那么你需要重新设计更加高效的算法或者对你现行的算法进行一定的优化。

Runtime Error （运行时错误） ：你的程序在计算答案的过程中由于出现了某种致命的原因异常终止。
你可以考虑以下几个要点来排除该错误： 1、程序是否访问了不该访问的内存地址，比如访问数组下标越界。 2、程序是否出现了除以整数 0，从而使程序异常。 3、程序是否调用了评判系统禁止调用的函数。 4、程序是否会出现因为递归过深或其他原因造成的栈溢出。

Compile Error （编译错误）: 你提交的程序并没有通过评判系统的编译，可根据更详细的编译信息修改你的程序。

Memory Limit Exceeded （使用内存超出限制）: 你提交的程序在运行输出所有的答案之前所调用的内存已经超过了题目中所限定的内存限制。
造成这种错误的原因主要有两个方面： 1、你的程序申请过多的内存来完成所要求的工作，即算法空间复杂度过高。 2、因为程序本身的某种错误使得程序不断的申请内存，例如因为某种原因出现了死循环，使得队列中不断的被放入元素。当然也千万别忽略自己的低级错误，比如在声明数组大小时多打了一个 0。

Output Limit Exceeded (输出超出限制): 你的程序输出了过多的东西，甚至超出了评判系统为了自我保护而设定的被评判程序输出大小的最高上限。
一般来说该种错误并不常见，一旦出现了也很好找原因。要么就是你在提交时忘记关闭你在调试时输出的调试信息（我经常输出 DP 时的数组来动态的观察状态的转移）；要么就是程序的输出部分出现了死循环，使得程序不断地输出而超出系统的限制。

题目1012：畅通工程

http://ac.jobdu.com/problem.php?pid=1012

#include<stdio.h>

//保存树结构,从1开始！！
int Tree[1001];

//找根函数
int findRoot(int son){
    //1.son为根
    if(Tree[son]==-1)
        return son;

    //2.递归选着son的根
    int father=findRoot(Tree[son]);

    //3.使所有son的父亲为根，来降低树的高度
    Tree[son]=father;

    return father;
}

int main(){
    //1.保存村庄数目与道路数目
    int n,m;

    //2.
    while(scanf("%d %d",&n,&m)!=EOF){
        //3.退出处理用例的条件
        if(n==0)
            break;
        //3.1初始化树
        for(int i=1;i<1001;i++){
            Tree[i]=-1;
        }

        //4.循环输入边，同时建立树
        for(int i=0;i<m;i++){
            int tem1,tem2;

            scanf("%d %d",&tem1,&tem2);

            //4.1寻找根节点
            tem1=findRoot(tem1);
            tem2=findRoot(tem2);

            //4.2如果根节点不同，则不联通
            if(tem1!=tem2)
                Tree[tem2]=tem1;
        }

        //5.输出连通分量的个数
        int rlt=0;
        for(int i=1;i<=n;i++){
            if(Tree[i]==-1)
                rlt++;
        }
        printf("%d\n",rlt-1);

    }

    return 0;
}

题目1017：还是畅通工程

http://ac.jobdu.com/problem.php?pid=1017 

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

//保存树
int Tree[101];

//查找树根的方法
int findRoot(int son){
    if(Tree[son]==-1)
        return son;

    int father=findRoot(Tree[son]);
    Tree[son]=father;

    return father;
}


//保存边的结构体
struct E{
    int x;
    int y;
    int cost;//权值

    //排序函数
    bool operator <(const E &b)const{
        return cost<b.cost;
    }
}edge[5000];

int main(){
    //1.保存村庄数目
    int n;

    //2.
    while(scanf("%d",&n)!=EOF){
        //3.跳出循环的条件
        if(n==0)
            break;
        //3.1初始化Tree数组
        for(int i=0;i<n;i++){
            Tree[i]=-1;
        }
        //3.2初始化道路最小长度
        int minw=0;

        //4.输入边
        for(int i=0;i<n*(n-1)/2;i++){
            scanf("%d %d %d",&edge[i].x,&edge[i].y,&edge[i].cost);
        }

        //5.对边进行排序
        sort(edge,edge+n*(n-1)/2);

        //6.遍历所有边，建立最小生成树
        for(int i=0;i<n*(n-1)/2;i++){
            int tem1=edge[i].x;
            int tem2=edge[i].y;

            tem1=findRoot(tem1);
            tem2=findRoot(tem2);

            if(tem1!=tem2){
                Tree[tem1]=tem2;
                minw+=edge[i].cost;
            }
        }
        //7.输出结果
        printf("%d\n",minw);
    }

    return 0;
}

题目1024：畅通工程

http://ac.jobdu.com/problem.php?pid=1024

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

int Tree[100];

//寻根方法
int findRoot(int son){
    if(Tree[son]==-1)
        return son;
    int father=findRoot(Tree[son]);
    Tree[son]=father;
    return father;
}

//保存边的结构体
struct E{
    int x;
    int y;
    int cost;
    //大小比较函数
    bool operator < (const E & b)const{
        return cost<b.cost;
    }
}edge[100];

int main(){
    //1.保存道路边数n,村庄个数m
    int n,m;

    //2.
    while(scanf("%d %d",&n,&m)!=EOF){

        //3.跳出条件
        if(n==0)
            break;

        //3.2初始化数组Tree
        for(int i=1;i<=m;i++){
            Tree[i]=-1;
        }

        //3.3初始化结果
        int rlt=0;

        //4.输入每条边
        for(int i=0;i<n;i++){
            scanf("%d %d %d",&edge[i].x,&edge[i].y,&edge[i].cost);
        }

        //5.对边进行排序
        sort(edge,edge+n);

        //6.循环每条边，建立最小生成树
        for(int i=0;i<n;i++){
            int tem1=edge[i].x;
            int tem2=edge[i].y;

            tem1=findRoot(tem1);
            tem2=findRoot(tem2);

            if(tem1!=tem2){
                Tree[tem1]=tem2;
                rlt+=edge[i].cost;
            }
        }

        //7.判断并输出结果
        int size1=0;
        for(int i=1;i<=m;i++){
            if(Tree[i]==-1)
                size1++;
        }
        if(size1==1){
            printf("%d\n",rlt);
        }else{
            printf("?\n");
        }

    }


    return 0;
}

题目1028：继续畅通工程

http://ac.jobdu.com/problem.php?pid=1028 (不知原因未通过)

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

//保存树
int Tree[101];

//查找树根的方法
int findRoot(int son){
    if(Tree[son]==-1)
        return son;

    int father=findRoot(Tree[son]);
    Tree[son]=father;

    return father;
}


//保存边的结构体
struct E{
    int x;
    int y;

    int isExist;

    int cost;//权值

    //排序函数
    bool operator <(const E &b)const{
        //先按照是否已经存在排序，存在的在前
        if(isExist>b.isExist)
            return true;
        return cost<b.cost;
    }
}edge[5000];

int main(){
    //1.保存村庄数目
    int n;

    //2.
    while(scanf("%d",&n)!=EOF){
        //3.跳出循环的条件
        if(n==0)
            break;
        //3.1初始化Tree数组
        for(int i=1;i<=n;i++){
            Tree[i]=-1;
        }
        //3.2初始化道路最小长度
        int minw=0;

        //4.输入边
        for(int i=0;i<n*(n-1)/2;i++){
            scanf("%d %d %d %d",&edge[i].x,&edge[i].y,&edge[i].cost,&edge[i].isExist);
        }

        //5.对边进行排序
        sort(edge,edge+n*(n-1)/2);

        //6.遍历所有边，建立最小生成树
        for(int i=0;i<n*(n-1)/2;i++){
            int tem1=edge[i].x;
            int tem2=edge[i].y;

            tem1=findRoot(tem1);
            tem2=findRoot(tem2);

            if(tem1!=tem2){
                Tree[tem1]=tem2;
                if(edge[i].isExist==0)
                    minw+=edge[i].cost;
            }
        }
        //7.输出结果
        printf("%d\n",minw);
    }

    return 0;
}

题目1444：More is better

http://ac.jobdu.com/problem.php?pid=1444

#include<stdio.h>

int Tree[10000001];
int countTree[10000001];

//寻根方法
int findRoot(int son){
    if(Tree[son]==-1)
        return son;
    int father=findRoot(Tree[son]);
    Tree[son]=father;
    return father;
}

int main(){

    //1.保存朋友的对数
    int n;

    //2.
    while(scanf("%d",&n)!=EOF){
        //2.1初始化保存树的数组
        for(int i=1;i<=10000000;i++){
            Tree[i]=-1;
            countTree[i]=1;
        }

        //3.循环输入每条边
        for(int i=0;i<n;i++){
            int a,b;
            scanf("%d %d",&a,&b);

            a=findRoot(a);
            b=findRoot(b);

            if(a!=b){
                Tree[a]=b;
                countTree[b]=countTree[a]+countTree[b];
            }
        }

        //4.输出结果
        int maxs=0;
        for(int i=1;i<10000000;i++){
            if(countTree[i]>maxs)
                maxs=countTree[i];
        }

        printf("%d\n",maxs);

    }

    return 0;
}

题目1144：Freckles

http://ac.jobdu.com/problem.php?pid=1144

#include<stdio.h>
#include<algorithm>
#include<math.h>

using namespace std;

int Tree[101];

//寻根函数
int findRoot(int son){
    if(Tree[son]==-1)
        return son;

    int father=findRoot(Tree[son]);
    Tree[son]=father;

    return father;
}

//保存每条边的结构体
struct E{
    int x;
    int y;
    double cost;

    bool operator < (const E & b)const{
        return cost<b.cost;
    }
}edge[10000];

//保存每个点的坐标
struct V{
    double x;
    double y;

    double getDistance(V v){
        double tem=(v.x-x)*(v.x-x)+(v.y-y)*(v.y-y);
        return sqrt(tem);
    }
}dot[101];

int main(){
    //1.保存一共有多少点
    int n;

    //2.
    while(scanf("%d",&n)!=EOF){
        //2.1初始化树
        for(int i=1;i<=n;i++)
            Tree[i]=-1;

        //3.循环输入点
        for(int i=1;i<=n;i++){
            scanf("%lf %lf",&dot[i].x,&dot[i].y);
        }

        //4.由每个点得到每条边
        int cnt=0;
        for(int i=1;i<=n;i++){
            for(int j=i;j<=n;j++){
                edge[cnt].x=i;
                edge[cnt].y=j;
                edge[cnt].cost=dot[i].getDistance(dot[j]);

                cnt++;
            }
        }

        //5.排序每条边
        sort(edge,edge+cnt);

        //6.循环每条边，来构建最小生成树
        double rlt=0;
        for(int i=0;i<cnt;i++){
            int tem1=edge[i].x;
            int tem2=edge[i].y;

            tem1=findRoot(tem1);
            tem2=findRoot(tem2);

            if(tem1!=tem2){
                Tree[tem1]=tem2;
                rlt+=edge[i].cost;
            }
        }

        //7.输出最后结果
        printf("%.2lf\n",rlt);
    }

    return 0;
}

题目1447：最短路

http://ac.jobdu.com/problem.php?pid=1447

#include<stdio.h>

//邻接矩阵来保存边
int ans[101][101];

int main(){
    //1.保存点数n,边数m
    int n,m;

    //2.
    while(scanf("%d %d",&n,&m)!=EOF&&n!=0&&m!=0){
        //2.1初始化邻接矩阵ans
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                ans[i][j]=-1;//表示无穷，没有边可达
            }
        }

        //3.输入m条边
        for(int i=0;i<m;i++){
            int tem1,tem2,tem3;
            scanf("%d %d %d",&tem1,&tem2,&tem3);

            ans[tem1][tem2]=tem3;
            ans[tem2][tem1]=tem3;
        }

        //4.Floyd求多源最短路
        for(int k=1;k<=n;k++){
            for(int i=0;i<=n;i++){
                for(int j=0;j<=n;j++){
                    if(ans[i][k]==-1||ans[k][j]==-1){
                        continue;
                    }
                    if(ans[i][j]==-1||ans[i][j]>ans[i][k]+ans[k][j]){
                        ans[i][j]=ans[i][k]+ans[k][j];
                    }
                }
            }
        }

        //5.输出结果
        printf("%d\n",ans[1][n]);
    }
    return 0;
}

使用Dijstra方法解决

#include<stdio.h>
#include<vector>
#define INF 123123123

using namespace std;

//保存边的结构体
struct E{
    int next;
    int cost;
};

//保存边的邻接链表数组
vector<E> edge[101];

//保存是否在集合P中的点
int mark[101];

//保存单源到其他点的距离
int dis[101];

int main(){
    //1.保存点数n，边数m
    int n,m;

    //2.
    while(scanf("%d %d",&n,&m)!=EOF&&n!=0&&m!=0){
        //2.1初始化邻接链表
        for(int i=1;i<=n;i++){
            edge[i].clear();
            mark[i]=0;
            dis[i]=INF;
        }
        //2.2
        dis[1]=0;


        //3.循环输入边
        for(int i=0;i<m;i++){
            int tem1,tem2,tem3;
            scanf("%d %d %d",&tem1,&tem2,&tem3);

            E e;
            e.next=tem2;
            e.cost=tem3;

            edge[tem1].push_back(e);

            e.next=tem1;

            edge[tem2].push_back(e);
        }

        //4.Dijstra算法求单源最短路,即1点到其他点的距离
        for(int k=0;k<n-1;k++){
            //4.1找距离1点最近的点
            int mincost=INF;
            int mind=0;
            for(int i=1;i<=n;i++){
                if(mark[i]!=0)
                    continue;
                if(dis[i]<mincost){
                    mind=i;
                    mincost=dis[i];
                }
            }

            //4.2记录最近点
            mark[mind]=1;

            //4.3 1->mind能否使其他的变短
            int a=edge[mind].size();
            for(int i=0;i<edge[mind].size();i++){
                if(mark[edge[mind][i].next]!=0||edge[mind][i].cost==INF)
                    continue;
                if(dis[edge[mind][i].next]>mincost+edge[mind][i].cost){
                    dis[edge[mind][i].next]=mincost+edge[mind][i].cost;
                }
            }
        }

        //5.输出结果
        printf("%d\n",dis[n]);


    }


    return 0;
}

题目1008：最短路径问题

http://ac.jobdu.com/problem.php?pid=1008

#include<stdio.h>
#include<vector>
#define INF 123123123

using namespace std;

//保存距离dis,保存花费cost,保存是否访问过该点mark
int dis[1001];
int cost[1001];
int mark[1001];

//辅助保存边的结构体
struct E{
    int next;
    int length;
    int cost;
};

//保存边的邻接链表
vector<E> edge[1001];

int main(){
    //1.保存点数n,边数m
    int n,m;

    //2.
    while(scanf("%d %d",&n,&m)!=EOF&&n!=0&&m!=0){
        //2.1初始化点
        for(int i=1;i<=n;i++){
            edge[i].clear();
            dis[i]=INF;
            cost[i]=0;
            mark[i]=0;
        }

        //3.循环输入每条边
        for(int i=0;i<m;i++){
            int tem1,tem2,tem3,tem4;
            scanf("%d %d %d %d",&tem1,&tem2,&tem3,&tem4);

            E e;
            e.next=tem2;
            e.length=tem3;
            e.cost=tem4;

            edge[tem1].push_back(e);

            e.next=tem1;

            edge[tem2].push_back(e);
        }

        //4.输入开始点s,结束点t
        int s,t;
        scanf("%d %d",&s,&t);
        //4.1初始化dis、cost、mark
        dis[s]=0;
        cost[s]=0;

        //5.Dijstra算法求最短路
        for(int k=0;k<n-1;k++){
            //5.1寻找距离s最近的点
            int mind=0;
            int temcost;
            int minlen=INF;
            for(int i=1;i<=n;i++){
                if(mark[i]==1)
                    continue;
                if(dis[i]<minlen){
                    minlen=dis[i];
                    temcost=cost[i];
                    mind=i;
                }
            }

            //5.2将mind点加入集合
            mark[mind]=1;

            //5.3 s->mind使其他点松弛
            for(int i=0;i<edge[mind].size();i++){
                if(mark[edge[mind][i].next]==1)
                    continue;
                if(dis[edge[mind][i].next]>minlen+edge[mind][i].length
                   ||cost[edge[mind][i].next]>temcost+edge[mind][i].cost
                   &&dis[edge[mind][i].next]==minlen+edge[mind][i].length){

                    dis[edge[mind][i].next]=minlen+edge[mind][i].length;
                    cost[edge[mind][i].next]=temcost+edge[mind][i].cost;
                }
            }
        }

        //6.输出结果
        printf("%d %d\n",dis[t],cost[t]);
    }

    return 0;
}
csdn_cx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论 (113页).pdf
09-06
图论 图论是一门古老而年轻的数学分支，它起源于游戏难题的研究。图论的内容十分丰富，应用得相当广泛，许多学科，诸如运筹学、信息论、控制论、网络理论、博弈论、化学、生物学、物理学、社会科学、语言学、计算机...
图论符号词典1
08-03
图论是数学的一个分支，主要研究点和点之间的连接关系，即“图”的结构和性质。在本节中，我们将深入探讨几个基本概念，包括无向图、有向图、图的度、连通性以及图的各种特殊类型。 首先，"G"通常用来代表一个图，...
2021年秋《离散数学》图论测试参考答案1
08-03
图论是离散数学的一个重要分支，主要研究点与点之间的连接结构，广泛应用于网络设计、数据压缩、算法设计等领域。本次2021年秋季《离散数学》的图论测试涵盖了图的基本概念、图的代数表示、道路与回路、二分图、树的...
电子科技大学图论及其应用第二章课后习题完整答案
最新发布
03-19
图论是离散数学的一个重要分支，主要研究点与点之间相互连接的结构，即图。在电子科技大学的《图论及其应用》第二章中，涉及了关于树、度数、生成树、割边和自环等核心概念。以下是这些知识点的详细说明： 1. **非...
图论及其应用 课后题全部答案
05-13
《图论及其应用》是一本深入探讨图论理论与实践的教材，课后习题是检验学习效果和深化理解的重要环节。在这个压缩包文件中，包含的“张先迪 李正良 图论及其应用课后题全部答案_1616142618”文档，很显然是为学习者...
图论及其应用
08-17
《图论及其应用》 作者 卜月华 东南大学 2002年7月第1版
图论基础知识（一）
11-14
介绍什么是图，图的存储方式以及图的遍历，并附上题目和代码，适合初学图论的人学习。
图论matlab程序大全
05-23
图论是数学的一个分支，主要研究点与点之间相互连接的关系，这些关系通常用边来表示。在MATLAB中，图论的应用广泛，包括网络分析、优化问题、数据建模等多个领域。本压缩包“图论matlab程序大全”显然包含了一系列与...
USTC CS图论课程部分答案
10-09
USTC CS图论课程部分答案 本资源提供了 USTC CS 图论课程的部分答案，涵盖了图论的基本概念、欧拉定理、图的度数序列、无环图、二分生成子图等几个方面。 首先，我们来讨论图论的基本概念。图论是数学的一个分支，...
图论算法基础讲解
"图论算法入门，适合初学者的图论算法教程，由孙云龙主讲，内容涵盖数值计算、规划方法、非数值运算及现代优化方法，包括图的一般理论、矩阵表示等。" 图论是计算机科学和数学中的一个重要分支，用于研究点和边构成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值