精华内容
下载资源
问答
  • 对于n个顶点的不带权有向图
    2022-05-09 08:39:44

    A:由n-1条权值最小的边构成的子图

    B:由n-1条权值之和最小的的边构成的子图

    C:由n-1条权值之和最小的边构成的连通子图

    D:由n个顶点构成的极小连通子图,且边的权值之和最小

    我选C

    更多相关内容
  • 带权有向图G中,给定一源点v,求从v到G中的其余各顶点的最短路径问题,叫做单源点的最短路径问题。 在常用的单源点最短路径算法中,迪杰斯特拉算法是最为常用的一种,是一种按照路径长度递增的次序产生最短路径...

    题目描述

    在带权有向图G中,给定一个源点v,求从v到G中的其余各顶点的最短路径问题,叫做单源点的最短路径问题。

    在常用的单源点最短路径算法中,迪杰斯特拉算法是最为常用的一种,是一种按照路径长度递增的次序产生最短路径的算法。

    在本题中,读入一个有向图的带权邻接矩阵(即数组表示),建立有向图并按照以上描述中的算法求出源点至每一个其它顶点的最短路径长度。

    可将迪杰斯特拉算法描述如下:

     

    输入

    输入的第一行包含2个正整数n和s,表示图中共有n个顶点,且源点为s。其中n不超过50,s小于n。

    以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数,如果大于0,则表示第i个顶点有指向第j个顶点的有向边,且权值为对应的整数值;如果这个整数为0,则表示没有i指向j的有向边。当i和j相等的时候,保证对应的整数为0。

    输出

    只有一行,共有n-1个整数,表示源点至其它每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径,输出-1。

    #include <iostream>
    #include <iomanip>
    using namespace std;
     
    #define Max 1000
    #define MVNum 100         //最大顶点数
    #define OK 1
     
    typedef int VerTexType; //顶点信息
    typedef int OtherInfo;    //和边相关的信息
    typedef int ArcType;
     
    //- - - - -图的邻接表存储表示- - - - -
    typedef struct {
       VerTexType vexs[MVNum];            //顶点表
       ArcType arcs[MVNum][MVNum];      //邻接矩阵
       int vexnum, arcnum;                //图的当前点数和边数
    } Graph;
     
    void CreateUDG(Graph &g)
    {
       //采用邻接矩阵表示法,创建无向图G
       /****在此下面完成代码***************/
        int i,j;
        for(i=0;i<g.vexnum;i++)
        {
            for(j=0;j<g.vexnum;j++)
            {
                cin>>g.arcs[i][j];
                if(g.arcs[i][j]==0)g.arcs[i][j]=Max;
            }
        }
       /***********************************/
    }//CreateUDN
     
     
    void shortDIJ(Graph g,int v0)
    {
        int i=0,v,w,Min,n=g.vexnum;
        int s[n],d[n],p[n];
        for(v=0;v<g.vexnum;v++)
        {
            s[v]=0;
            d[v]=g.arcs[v0][v];
            if(d[v]<Max)p[v]=v0;
            else p[v]=-1;
     
        }
        s[v0]=1;
        d[v0]=0;
        for(i=1;i<n;i++)
        {
            Min=Max;
            for(w=0;w<n;w++)
            {
                if(!s[w]&&d[w]<Min)
                {
                    v=w;Min=d[w];
                }
            }
            s[v]=1;
            for(w=0;w<n;w++)
            {
                if(!s[w]&&d[v]+g.arcs[v][w]<d[w])
                {
                    d[w]=d[v]+g.arcs[v][w];
                    p[w]=v;
                }
            }
        }
        for(i=0;i<n;i++)
        {
            if(i!=v0&&d[i]<Max)cout<<d[i]<<" ";
            else if(d[i]==Max)cout<<-1<<" ";
        }
     
    }
     
    int main()
    {
       Graph g;
       int v0;
       cin>>g.vexnum>>v0;
       CreateUDG(g);
       shortDIJ( g, v0);
       return 0;
    }
     

    样例输入 Copy

    4 1
    0 3 0 1
    0 0 4 0
    2 0 0 0
    0 0 1 0
    

    样例输出 Copy

    6 4 7 
    

    提示

    在本题中,需要按照题目描述中的算法完成迪杰斯特拉算法,并在计算最短路径的过程中将每个顶点是否可达记录下来,直到求出每个可达顶点的最短路径之后,算法才能够结束。

    迪杰斯特拉算法的特点是按照路径长度递增的顺序,依次添加下一条长度最短的边,从而不断构造出相应顶点的最短路径。

    另外需要注意的是,在本题中为了更方便的表示顶点间的不可达状态,可以使用一个十分大的值作为标记。

    展开全文
  • 如果从vi到vj弧,则从vi到vj存在一条长度为arcs[i][j]的路径,该路径一定是最短路径,尚需进行n次试探。 首先考虑路径(vi, v0, vj)是否存在(判别弧(vi, v0)和(v0, vj)是否存在)。 如果存在,则比较(vi,...

    在这里插入图片描述基本思想是:
    假设求从顶点vi到vj的最短路径。
    如果从vi到vj有弧,则从vi到vj存在一条长度为arcs[i][j]的路径,该路径不一定是最短路径,尚需进行n次试探。
    首先考虑路径(vi, v0, vj)是否存在(判别弧(vi, v0)和(v0, vj)是否存在)。
    如果存在,则比较(vi, vj)和(vi, v0, vj)的路径长度,取长度较短者为从vi到vj的中间顶点的序号不大于0的最短路径。
    假如在路径上再增加一个顶点v1,也就是说,如果(vi, …, v1)和(v1, …, vj)分别是当前找到的中间顶点的序号不大于0的最短路径,那么(vi, …, v1, … , vj)就有可能是从vi到vj的中间顶点的序号不大于1的最短路径。
    将它和已经得到的从vi到vj中间顶点序号不大于0的最短路径相比较,从中选出中间顶点的序号不大于1的最短路径之后,再增加一个顶点v2,继续进行试探,依此类推。
    在一般情况下,若(vi, …, vk)和(vk, …, vj)分别是从vi到vk和从vk到vj的中间顶点的序号不大于k-1的最短路径,则将(vi, …, vk, …, vj)和已经得到的从vi到vj且中间顶点序号不大于k-1的最短路径相比较,其长度较短者便是从vi到vj的中间顶点的序号不大于k的最短路径。
    这样,在经过n次比较后,最后求得的必是从vi到vj的最短路径。
    按此方法,可以同时求得各对顶点间的最短路径。

    求任意两顶点间的最短路径Floyd算法如下:

    #include <iostream>
    using namespace std;
    
    const int MAXW = 30000;
    const int MaxVertexNum = 30;
    typedef char VertexType;
    class MGraph
    {
    public:
    	void CreateGraph();
    	void ShortestPath_Floyd();
    	void Print_Path_Floyd(int v,int w);
    
    private:
    	int vertexnum;
    	VertexType vertexs[MaxVertexNum];
    	int edgenum;
    	bool P[MaxVertexNum][MaxVertexNum][MaxVertexNum];
    	int D[MaxVertexNum][MaxVertexNum];
    	int arcs[MaxVertexNum][MaxVertexNum];
    };
    
    void MGraph::CreateGraph()
    {
    	cout << "请输入节点数和边条数" << endl;
    	cin >> vertexnum >> edgenum;
    	for (int i = 0; i < vertexnum; i++)
    		for (int j = 0; j < vertexnum; j++)
    			arcs[i][j] = MAXW;
    	cout << "请依次输入按序号0到n顶点的中存储的信息" << endl;
    	for (int i = 0; i < vertexnum; i++)
    	{
    		cin >> vertexs[i];
    	}
    	cout << "下面输入边的信息" << endl;
    	for (int i = 0; i < edgenum; i++)
    	{
    		int v1, v2, w;
    		cout << "输入边<i,j>对应的顶点序号i,j,然后再输入该边的权值" << endl;
    		cin >> v1 >> v2 >> w;
    		arcs[v1][v2] = w;
    	}
    }
    
    void MGraph::ShortestPath_Floyd()
    {//用Floyd算法求有向图G中各对顶点v和w之间的最短路径P[v][w]及其带权长度D[v][w]
    
    	//若P[v][w][u] = 1,则u是从v到w当前求得的最短路径上的顶点
    
    	for (int v = 0;v<vertexnum;v++)
    		for (int w = 0; w < vertexnum; w++)
    		{
    			D[v][w] = arcs[v][w];
    				for (int u = 0; u < vertexnum; u++) P[v][w][u] = 0;
    			if (D[v][w] < MAXW)//从v到w有直接路径
    			{
    				P[v][w][v] = 1;
    				P[v][w][w] = 1;
    			}
    		}
    	for (int u = 0;u< vertexnum;u++)
    			for (int v = 0;v<vertexnum;v++)
    				for (int w = 0; w < vertexnum; w++)
    				{
    					if (D[v][u] + D[u][w] < D[v][w])
    					{
    						D[v][w] = D[v][u] + D[u][w];
    						P[v][w][u] = 1;
    					}
    				}
    }
    
    void MGraph::Print_Path_Floyd(int v, int w)
    {
    	int i;
    	for (i = 0; i < vertexnum; i++)
    	if (i != v && i != w && P[v][w][i] == true) break;
    
    		if (i >= vertexnum) cout << v << "->" << w << endl;
    		else
    		{
    			Print_Path_Floyd(v, i);
    			Print_Path_Floyd(i, w);
    		}
    }
    
    
    int main()
    {
    	MGraph g;
    	g.CreateGraph();
    	g.ShortestPath_Floyd();
    	int v, w;
    	cin >> v >> w;
    	g.Print_Path_Floyd(v, w);
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 1063: 带权有向图计算 题目描述 假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。 输入 第一行第一整数n表示顶点的个数(顶点编号为0到n-1),第二行表示顶点i和j,接下来是为一...

    1063: 带权有向图计算
    题目描述
    假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。
    输入
    第一行第一个整数n表示顶点的个数(顶点编号为0到n-1),第二行表示顶点i和j,接下来是为一个n*n大小的整数矩阵,表示图的邻接关系。数字为大于0表示邻接值,-1表示不邻接,对角线为0。
    输出
    第一行为最大权值,第二行为有向边。第三行为最小权值,第四行为有向边。
    由于OJ无法显示尖括号,所以这里用圆扩号来表示有序对。
    样例输入

    5
    0 5 -1 23 -1
    -1 0 31 56 -1
    -1 -1 0 -1 -1
    -1 -1 -1 0 -1
    56 -1 -1 19 0

    样例输出

    56
    (1 3)(4 0)
    5 (0 1)
    注意:由于显示的问题,输出数据应采用尖括号。

    思路:

    1. 输入邻接矩阵
    2. for循环找最大权值
    3. 打印最大权值
    4. for循环打印最大权值的两点
    5. for循环找最小权值
    6. 打印最小权值
    7. for循环打印最大权值的两点
    tips:关于权值最值问题的核心思想就是for循环

    【拓展】最小值的初始即使再大也会有漏洞,因为你不能确定最小权值一定小于5815,但玄幻的OJ还是让我们过了,如果你想优化代码可以将min=5815删除然后使用下面注释掉的41-51行代码

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int n, a[100][100], max, min;       //n为顶点的个数,max为最大权值,min为最小权值
    	cin >> n;							//scanf("%d", &n);
    	for(int i=0;i<n;i++)                //输入邻接矩阵
    	{
    		for(int j=0;j<n;j++)
    		{
    			cin >> a[i][j];				//scanf("%d", &a[i][j]);
    		}
    	}
    	max=0;
        min=5815;                           //最小值的初始即使再大也会有漏洞,因为你不能确定最小权值一定小于5815,
    	for(int i=0;i<n;i++)				//计算最大权值 
    	{
    		for(int j=0;j<n;j++)
    		{
    			if(a[i][j]>max)
    			{
    				max=a[i][j];
    			}
                if(a[i][j]<min&&a[i][j]>0)
    			{
    				min=a[i][j];
    			}
    		}
    	}
    	cout << max <<endl;                 //printf("%d\n", max);
    	for(int i=0;i<n;i++)				//输出最大权值的点
    	{
    		for(int j=0;j<n;j++)
    		{
    			if(a[i][j]==max)
    			{
    				cout << "<" << i <<" " <<j << ">"; 
    			}
    		}
    	}
    	//min=max;
    	//  for(int i=0;i<n;i++)				//计算最小权值 
    	// {
    	// 	for(int j=0;j<n;j++)
    	// 	{
    	// 		if(a[i][j]<min&&a[i][j]>0)
    	// 		{
    	// 			min=a[i][j];
    	// 		}
    	// 	}
    	// }
    	cout <<endl << min <<endl;			//printf("\n%d\n", min);
    	for(int i=0;i<n;i++)				//输出最小权值的点
    	{
    		for(int j=0;j<n;j++)
    		{
    			if(a[i][j]==min)
    			{
    				cout << "<" << i <<" " <<j << ">"; 
    			}
    		}
    	}
    	
    	return 0;
     } 
     
    

    以上方法仅供参考,欢迎互联网的广大朋友们提出指正。

    展开全文
  • 个图G=(V,E)是多段,是指顶点集V划分成k互不相交的子集Vi,使得E中任意一条边(u,v)必u,v属于两不同的子集。A是源点,E是终点。 1 动态规划 1.1 动态规划逆序解法 从后向前,E->A。next数组储存路径上...
  • 使用C语言实现对于带权图最短路的求解,经测试能够正确求解带权图的最短路问题,使用编程语言求解图论中的经典问题。
  • 1063: 带权有向图计算

    2021-05-14 15:18:17
    假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。 输入 第一行第一整数n表示顶点的个数(顶点编号为0到n-1),第二行表示顶点i和j,接下来是为一个n*n大小的整数矩阵,表示图的...
  • 采用弗洛伊德算法求带权有向图的最短路径

    千次阅读 多人点赞 2019-03-24 21:22:42
    弗洛伊德(Floyd)算法也是一种用于寻找给定的加权顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 Floyd优缺点分析 优点:容易理解,...
  • Dijkstra算法是从一个顶点到其余各顶点的最短路径...* 采用迪杰斯特拉算法求带权有向图的最短路径 * 实验目的: * 领会迪杰斯特拉算法求带权有向图中单源最短路径的过程和相关算法设计 * 实验内容: * 编写程序实现求...
  • } bool CreateGraph(Graph* g) { cout 顶点" ; for (int i = 0; i < g->vertexNum; i++) { cin >> g->Vertex[i]; } VertexType a, b; int n; cout 添加的边" ; for (int i = 0; i < g->edgeNum; i++) { ...
  • /**** 带权重有方向图* 介绍了Dijkstra算法:最短...b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图)c) 所有边权非负(任取(i,j)∈E都有Wij≥0);2) 算法描述:a) 初始化:dis[v]=maxint(v∈V...
  • 带权有向图中的最小环

    千次阅读 2019-04-05 15:42:33
    /** * 实验题目: * 求带权有向图中的最小环 * 实验目的: * 掌握Floyd算法在求解...* 编写一程序,输出带权有向图中的一最小环。 * */ #include <stdio.h> #include <malloc.h> #define INF ...
  • C++ 带权有向图 最短路径及长度

    热门讨论 2008-10-10 15:39:33
    C++程序,它能根据读入的带权有向图G的数据,构造并输出图G的顶点Vi到其它每个顶点的最短路径及长度,最后输出图G的拓扑序列。图的输入形式为n i i0 j0 w0 i1 j1 w1 i2 j2 w2 ...im jm wm -1 -1 -1(-1 -1 -1为...
  • 向图 前面了解到树是单一根结点的非线性结构,图(graph)也是一种非线性结构,其中的结点可以与许多其他的结点相连接,并且没有特定的父/子关系。图和图论的研究是数学和计算机科学中的完整学科。 ...
  • 首先,引进一辅助向量D,它的每分量D[i]表示当前所找到的从始点v0到每终点vi的最短路径的长度。 它的初态为:若从v0到vi弧,则D[i]为弧上的权值;否则,置D[i]为∞。 显然,长度为 D[j]=Min{D[i]|vi∈V-S}, ...
  • 带权有向图

    千次阅读 2015-12-16 23:24:53
    //该函数的目的是记录带权有向图 #ifndef EDGE_H #define EDGE_H template class Edge{ public: //该图主要包括(起点,终点,权重) int start; int end; T weight; Edge(); Edge(int st, int en, T wei); b
  • 像这种带权有向图,每一行都表示该行标号对应列标号的有向权值,本身到本身的数值为0,没办法到达的数值为∞ 2.最优子结构 i,j是图里面的两不同顶点,设p为从i到j的经过{k+1,k+2,...n}点的最短路...
  • 14.假设不带权有向图采用邻接矩阵G存储,设计实现以下功能的算法。 (1) 求出图中每个顶点的入度。 (2)求出图中每个顶点的出度。 (3)求出图中出度为0的顶点数。 15. 假设不带权有向图采用邻接表G存储,设计...
  • 声明:我测试的样例答案都正确,如果代码问题还请指出。 代码: #include<iostream> #include<list> #include<vector> #include<queue> #include<set> #include<memory.h> #...
  • 带权有向图最短路径

    千次阅读 2014-07-28 13:14:36
    1、带权有向图最短路径 1) 适用条件&范围: a) 单源最短路径(从源点s到其它所有顶点v); b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图) c) 所有边权非负(任取(i,j)∈E都有Wij≥0); 2) 算法...
  • Python-建立有向带权图

    千次阅读 2020-12-27 16:59:28
    # 邻接列表构图,每node保存与本节点相连的节点 def __init__(self, key): # 顶点的key self.id = key # 用于保存和哪些点相连,key为node的key,val为连接权重 self.connectedTo = {} def addNeighbor...
  • 第七章(3)生成树和最小生成树.pdf
  • 2017-07-03 16:54:00
    顶点的度、入度和出度:一图的所有顶点的度之和...(3)带权的有向图的邻接矩阵一般是稀疏矩阵,当图的顶点较多时,可以采用三元组表的方法存储邻接矩阵。 缺点:邻接矩阵表示法对于稀疏图来说合理,因为太浪费空
  • 给定带权有向图G和源点v0,求从源点v0到G中其余各顶点的最短路径。迪杰斯特拉算法是对有权图进行搜索,但是如果引用于无权图或者是权值相等的图,就是广度优先搜索。(注意是有向图)算法描述 对于N=(V,E),将N...
  • 带权有向图找到全部的环完整源码#include #include <vector> #include #include #include using namespace std;int V, E; int n;//带权有向图 map, vector, int , double>>> EWD;bool m
  • 创建一个带权路径的 有向图,无向图, 输出从v0到其他各个顶点的最短路径 采用Dijstra算法求一个顶点到其他所有顶点的最短路径 Dijstra code: /* 创建一个带权路径的 有向图,无向图, 输出从v0到其他各个顶点的最短...
  • 带权向图的邻接矩阵表示法(C语言实现)

    千次阅读 多人点赞 2021-11-02 23:53:03
    文章目录带权向图的邻接矩阵表示法(C语言实现)一、邻接矩阵表示法二、本次程序实现的功能三、带权向图的结构体定义四、创建无向图及邻接矩阵五、输出邻接矩阵六、输出顶点集合七、判断两顶点是否邻接八、全部...
  • - Java实现有向带权图的邻接表表示法
  • 带权有向图计算 5000(ms) 10000(kb) 2297/5754 假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。 输入 第一行第一整数n表示顶点的个数(顶点编号为0到n-1),第二行表示...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,326
精华内容 4,130
热门标签
关键字:

对于n个顶点的不带权有向图