精华内容
下载资源
问答
  • 带权有向图

    千次阅读 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
    //头文件Edge.h  Graph.h
    //Edge.h
    //该函数的目的是记录带权有向图
    #ifndef EDGE_H
    #define EDGE_H
    template<typename T>
    class Edge{
    public:
    	//该图主要包括(起点,终点,权重)
    	int start;
    	int end;
    	T weight;
    	Edge();
    	Edge(int st, int en, T wei);
    	bool operator<(const Edge<T>& str);
    	bool operator>(const Edge<T>& str);
    };
    template<typename T>
    Edge<T>::Edge()
    {
    
    }
    template<typename T>
    Edge<T>::Edge(int st, int en, T wei)
    {
    	this->start = st;
    	this->end = en;
    	this->weight = wei;
    }
    template<typename T>
    bool Edge<T>::operator<(const Edge<T>& str)
    {
    	return this->weight < str->weight;
    }
    template<typename T>
    bool Edge<T>::operator>(const Edge<T>& str)
    {
    	return this->weight>str->weight;
    }
    #endif // !EDGE_H
    //Graph.h
    #ifndef GRAPH_H
    #define GRAPH_H
    #include"Edge.h"
    #include<iostream>
    using namespace std;
    template<typename T>
    class Graph{
    private:
    	//该头文件中的私有变量应该包括(顶点的数目,边的数目,存储节点权重的二位数组,记录每个节点是否被访问过的数组)
    	int vertexNum;
    	int edgeNum;
    	Edge<T> edge;
    	bool *Mark;
    	T **martrix;
    public:
    	Graph();
    	Graph(int n);
    	void Init();
    	~Graph();
    	//该类应该包括的功能函数(添加边,删除边,获取权重,
    	//获取顶点的第一条边,获取顶点的度数,获取顶点(以该顶点为起点的)的所有边的信息,
    	//获取边的是否有边,判断两个节点之间是否有边的关系)
    	bool isEdge(int start, int end)const;
    	bool isHaveEdge(int start)const;
    	void setEdge(int start, int end, T weight);
    	void Delete(int start, int end);
    	T getWeight(int start, int end)const;
    	bool firstEdge(int start);
    	//在计算有向图的度数是,要注意(计算方法是行的和加上列的和)
    	int Number(int start)const;
    	//得到以start为起点的边的信息(即输出所有边的权值)
    	void getAllEdgeInfo(int start)const;
    	void Print(int n)
    	{
    		if (firstEdge(n))
    		{
    			cout << edge.weight << endl;
    		}
    	}
    };
    template<typename T>
    Graph<T>::Graph()
    {
    	this->vertexNum = 0;
    	this->edgeNum = 0;
    	this->edge = NULL;
    	this->martrix = NULL;
    	this->Mark = NULL;
    }
    template<typename T>
    Graph<T>::Graph(int n)
    {
    	this->vertexNum = n;
    	this->Mark = new bool[this->vertexNum];
    	this->martrix = new int*[this->vertexNum];
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		this->martrix[i] = new int[this->vertexNum];
    	}
    	if (this->martrix == NULL || this->Mark == NULL)
    	{
    		cout << "空间未成功开辟" << endl;
    		exit(true);
    	}
    	this->Init();
    }
    template<typename T>
    void Graph<T>::Init()
    {
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		this->Mark[i] = false;
    		for (int j = 0; j < this->vertexNum; j++)
    		{
    			this->martrix[i][j] = 0;
    		}
    	}
    }
    template<typename T>
    Graph<T>::~Graph()
    {
    	delete Mark;
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		delete martrix[i];
    	}
    	this->martrix = NULL;
    	this->Mark = NULL;
    }
    template<typename T>
    bool Graph<T>::isEdge(int start, int end)const
    {
    	if (start>this->vertexNum || end > this->vertexNum)
    	{
    		cout << "start/end已超出范围" << endl;
    		exit(true);
    	}
    	if (this->martrix[start - 1][end - 1] != 0)
    	{
    		return true;
    	}
    }
    template<typename T>
    bool Graph<T>::isHaveEdge(int start)const
    {
    	if (start > this->vertexNum)
    	{
    		cout << "start已超出范围" << endl;
    		exit(true);
    	}
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		if (this->martrix[start - 1][i] != 0)
    			return true;
    	}
    	return false;
    }
    template<typename T>
    void Graph<T>::setEdge(int start, int end, T weight)
    {
    	if (start>this->vertexNum || end > this->vertexNum)
    	{
    		cout << "start/end已超出范围" << endl;
    		return;
    	}
    	this->martrix[start - 1][end - 1] = weight;
    }
    template<typename T>
    void Graph<T>::Delete(int start, int end)
    {
    	if (start>this->vertexNum || end > this->vertexNum)
    	{
    		cout << "start/end已超出范围" << endl;
    		return;
    	}
    	this->martrix[start - 1][end - 1] = 0;
    }
    template<typename T>
    T Graph<T>::getWeight(int start, int end)const
    {
    	if (start>this->vertexNum || end > this->vertexNum)
    	{
    		cout << "start/end已超出范围" << endl;
    		exit(true);
    	}
    	return this->martrix[start - 1][end - 1];
    }
    template<typename T>
    bool Graph<T>::firstEdge(int start)
    {
    	if (start>this->vertexNum)
    	{
    		cout << "start已超出范围" << endl;
    		exit(true);
    	}
    	int i = 0;
    	for (; i < this->vertexNum; i++)
    	{
    		if (this->martrix[start - 1][i] != 0)
    		{
    			edge.start = start;
    			edge.end = i + 1;
    			edge.weight = this->martrix[start - 1][i];
    			break;
    		}
    	}
    	if (i < this->vertexNum)
    	{
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    template<typename T>
    int Graph<T>::Number(int start)const
    {
    	if (start>this->vertexNum)
    	{
    		cout << "start已超出范围" << endl;
    		exit(true);
    	}
    	int count = 0;
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		if (this->martrix[start - 1][i] != 0)
    		{
    			count++;
    		}
    	}
    	return count;
    }
    template<typename T>
    void Graph<T>::getAllEdgeInfo(int start)const
    {
    	if (start>this->vertexNum)
    	{
    		cout << "start已超出范围" << endl;
    		exit(true);
    	}
    	for (int i = 0; i < this->vertexNum; i++)
    	{
    		if (this->martrix[start - 1][i] != 0)
    		{
    			cout << "(" << start << "," << i + 1 << ")" << this->martrix[start - 1][i] << " ";
    		}
    	}
    	cout << endl;
    }
    #endif // !GRAPH_H
    //主函数
    #include"Graph.h"
    int main(int argc, char argv[])
    {
    	Graph<int>graph(5);
    	graph.setEdge(1, 1, 2);
    	graph.setEdge(1, 2, 6);
    	graph.setEdge(1, 6, 5);
    	graph.Print(1);
    	graph.Delete(1, 1);
    	graph.Print(1);
    	return 0;
    }
    

    展开全文
  • 带权有向图计算

    千次阅读 2018-06-14 17:32:21
    假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。输入第一行第一整数n表示顶点的个数(顶点编号为0到n-1),第二行表示顶点i和j,接下来是为一个n*n大小的整数矩阵,表示图的邻接...
    假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。

    输入

    第一行第一个整数n表示顶点的个数(顶点编号为0到n-1),第二行表示顶点i和j,接下来是为一个n*n大小的整数矩阵,表示图的邻接关系。数字为大于0表示邻接值,-1表示不邻接,对角线为0。

    输出

    第一行为最大权值,第二行为有向边。第三行为最小权值,第四行为有向边。 由于OJ无法显示尖括号,所以这里用圆扩号来表示有序对。

    样例输入

    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> 
    <0 1> 
    #include<iostream>
    using namespace std;
    #define max 100
    int main()
    {
        int e[max][max], i, j, n;
        cin >> n;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                cin >> e[i][j];
            }
        }
        int Lmax = 0,Lmin=9999;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (e[i][j]>0)
                {
                    if (Lmax < e[i][j])Lmax = e[i][j];
                    if (Lmin>e[i][j])Lmin = e[i][j];
                }
            }
        }
        cout << Lmax << endl;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (e[i][j] == Lmax)cout << "<" << i<<" " << j << ">";
            }
        }
        cout << endl;
        cout << Lmin<<endl;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (e[i][j] == Lmin)cout << "<" << i<<" " << j << ">";
            }
        }
        //system("pause");
        return 0;
    }

    展开全文
  • ) //N顶点数量 for ( i=0; i<N; i++ ) for ( j=0; j<N; j++ ) if ( A[i][j] > A[i][k] + A[k][j] ) { A[i][j] = A[i][k] + A[k][j]; path[i][j...
  • 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为...
  • 1063: 带权有向图计算

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

    题目描述
    假设带权有向图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)
    注意:由于显示的问题,输出数据应采用尖括号。
    
    #include<stdio.h>
    #define MaxSize 1000
    int G[MaxSize][MaxSize];
    int main()
    {
        int n,MaxDepth=-1,num,MinDepth=10000;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&num);
                G[i][j]=num;
                if(MaxDepth<num) MaxDepth=num;
                if(num>0)//最小值为正数
                {
                    if(MinDepth>num) MinDepth=num;
                }
            }
        }
        printf("%d\n",MaxDepth);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(G[i][j]==MaxDepth)
                {
                    printf("<%d %d>",i,j);
                }
            }
        }
        printf("\n");
        printf("%d\n",MinDepth);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(G[i][j]==MinDepth)
                {
                    printf("<%d %d>",i,j);
                }
            }
        }
    }
    
    
    展开全文
  • 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;
     } 
     
    

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

    展开全文
  • 14.假设不带权有向图采用邻接矩阵G存储,设计实现以下功能的算法。 (1) 求出图中每个顶点的入度。 (2)求出图中每个顶点的出度。 (3)求出图中出度为0的顶点数。 15. 假设不带权有向图采用邻接表G存储,设计...
  • 带权有向图最短路径

    千次阅读 2014-07-28 13:14:36
    1、带权有向图最短路径 1) 适用条件&范围: a) 单源最短路径(从源点s到其它所有顶点v); b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图) c) 所有边权非负(任取(i,j)∈E都有Wij≥0); 2) 算法...
  • 带权有向图找到全部的环完整源码#include #include <vector> #include #include #include using namespace std;int V, E; int n;//带权有向图 map, vector, int , double>>> EWD;bool m
  • 带权有向图计算 5000(ms) 10000(kb) 2297/5754 假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。 输入 第一行第一整数n表示顶点的个数(顶点编号为0到n-1),第二行表示...
  • /** * 实验题目: * 求带权有向图中的最小环 * 实验目的: * 掌握Floyd算法在求解...* 编写一程序,输出带权有向图中的一最小环。 * */ #include <stdio.h> #include <malloc.h> #define INF ...
  • 假设带权有向图G采用邻接矩阵存储,计算图的最大权值、最小权值以及对应的有向边。
  • Dijkstra算法是从一个顶点到其余各顶点的最短路径...* 采用迪杰斯特拉算法求带权有向图的最短路径 * 实验目的: * 领会迪杰斯特拉算法求带权有向图中单源最短路径的过程和相关算法设计 * 实验内容: * 编写程序实现求...
  • 如果从vi到vj弧,则从vi到vj存在一条长度为arcs[i][j]的路径,该路径一定是最短路径,尚需进行n次试探。 首先考虑路径(vi, v0, vj)是否存在(判别弧(vi, v0)和(v0, vj)是否存在)。 如果存在,则比较(vi,...
  • 数据结构与算法 弗洛伊德算法多源输出带权有向图最短路径 目的与要求: 领会弗洛伊德算法求带权有向图多源最短路径的过程和算法设计。 实验设备及软件: 计算机,VC6.0 代码: #include<stdio.h> #include&...
  • 给定带权有向图G和源点v0,求从源点v0到G中其余各顶点的最短路径。迪杰斯特拉算法是对有权图进行搜索,但是如果引用于无权图或者是权值相等的图,就是广度优先搜索。(注意是有向图)算法描述 对于N=(V,E),将N...
  • } 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++) { ...
  • 像这种带权有向图,每一行都表示该行标号对应列标号的有向权值,本身到本身的数值为0,没办法到达的数值为∞ 2.最优子结构 i,j是图里面的两不同顶点,设p为从i到j的经过{k+1,k+2,...n}点的最短路...
  • 由于是不带权,采用广度优先,对于每一结点,都需要将和它联通的所有结点访问,比较是否等于v //G采用邻接表存储,设计算法求不带权无向连通G从顶点u到顶点v的一条最短路径 //由于是不带权的无向连通,...
  • 个图G=(V,E)是多段,是指顶点集V划分成k互不相交的子集Vi,使得E中任意一条边(u,v)必u,v属于两不同的子集。A是源点,E是终点。 1 动态规划 1.1 动态规划逆序解法 从后向前,E->A。next数组储存路径上...
  • 给定一个带权有向图D与源点v, 求从v到D中其他顶点的最短路径。限定边上的权值大于或等于0. 2. java实现: [code="java"]package boke.graph.shortpath1; import java.util.Stack; /** *...
  • 弗洛伊德(Floyd)算法也是一种用于寻找给定的加权顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 Floyd优缺点分析 优点:容易理解,...
  • G = nx.DiGraph() # 创建有向图 G.add_edge(1, 2, weight=1) # 添加 带权边,weight表示边权 G.add_edge(1, 3, weight=1) G.add_edge(3, 1, weight=1) G.add_edge(2, 4, weight=1) print(G[1]) # 邻居的dict for ...
  • 本文转载自chinaunix 数据结构——带权有向图(最短路径算法Dijkstra算法) 1.Dijkstra1) 适用条件&范围:a) 单源最短路径(从源点s到其它所有顶点v);b) 有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的...
  • //排序失败,有向图中有回路 } else { return true; //拓扑排序成功 } } #include "ALGraph.h" #include int main() { ALGraph* g=new ALGraph; InitGraph(g); CreateGraph(g); TopologicalSort(g);...
  • 数据结构——带权有向图(最短路径算法Dijkstra算法) Dijkstra算法-寻找有向图中最短路径 Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻发现的。算法解决的是有向图中最短路径问题。 举例来说,如果图...
  • 基本思路 - 设 中的顶点集为V; 最短路径已确定的顶点集为S 1.将源点添加到S中 2.计算出每个顶点的估计距离 - 除了终点在V-S中,其余路径中的点都在S中 3.把最小估计距离所连接的顶点放入S中,此时可能会改变顶点...
  • 有向图中包含n个顶点,编号为0至n-1。 输入格式: 输入第一行为两正整数n和e,分别表示图的顶点数和边数,其中n不超过20000,e超过1000。接下来e行表示每条边的信息,每行为3非负整数a、b、c,其中a和b表示该边...
  • 昨晚考研的朋友发来这道题,平日很少接触的算法,只会...知道没有存在隐藏的bug,如果人可以帮我指出感激不尽。 关于结点的类 class Node { public int val; public List<Node> children; pub...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,749
精华内容 3,499
关键字:

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