实验5——图及其应用

已于 2023-12-09 14:57:53 修改
阅读量599 收藏 9
点赞数 13
分类专栏： 头歌实验平台 文章标签： 算法
于 2023-12-09 14:48:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T19583553694/article/details/134894991
版权

图的邻接矩阵实验

第1关：建立无向网的邻接矩阵

任务描述

本关任务：建立无向网的邻接矩阵。

相关知识

1.无向网的定义 2.无向网的邻接矩阵

编程要求

本关任务是实现右侧编辑栏里面的代码编写，实现无向网的邻接矩阵的建立。

输入格式：

第1行：顶点数n和边数m 第2行：输入n个字符，表示顶点的名称 接下来的m行，依次输入每条边

输出格式：

第1行：图的邻接矩阵： 其后的m行为图的邻接矩阵（其中∞表示无穷大）

#include <cstdio>
#include <iostream> 
using namespace std;

#define MaxInt 32767   			  	//最大值
#define MVNum 20    			  	//最大顶点数
typedef  struct { 
   int  vexnum,arcnum;		 	 	//顶点数和边的数目 
   char vexs[MVNum]; 			  	//顶点向量
   int  arcs[MVNum][MVNum];			//邻接矩阵    
} AMGraph;

int LocateVex(AMGraph G, char v) {
    int i;  
    for (i = 0; i < G.vexnum; i++)
        if (G.vexs[i] == v) return i;
    return -1;
}

void CreateUDN(AMGraph &G)  		//创建无向网的邻接矩阵 
{
    cin >> G.vexnum >> G.arcnum;

    for (int i = 0; i < G.vexnum; i++) {
        cin >> G.vexs[i];
    }

    // 初始化邻接矩阵
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            if(i==j)
                G.arcs[i][j] = 0;
            else
                G.arcs[i][j] = MaxInt;
        }
    }

    for (int k = 0; k < G.arcnum; k++) {
        char v1, v2;
        int w;
        cin >> v1 >> v2 >> w;
        int i = LocateVex(G, v1);
        int j = LocateVex(G, v2);
        if (i != -1 && j != -1) {
            G.arcs[i][j] = w;
            G.arcs[j][i] = w;  // 无向图，对称矩阵
        } 
        // else {
        //     cout << "输入顶点名称有误！" << endl;
        //     k--;  // 重新输入当前边
        // }
    }
}

void PrintGraph(AMGraph G)          //输出图的邻接矩阵	 
{    
    cout << "图的邻接矩阵：";
    for (int i = 0; i < G.vexnum; i++) {
        cout << endl;
        for (int j = 0; j < G.vexnum; j++) {
            if (G.arcs[i][j] == MaxInt) 
                printf("    ∞");
            else 
                printf("%5d", G.arcs[i][j]);
        }	 
    }
}

int main()
{
    AMGraph G; 
    CreateUDN(G);
    PrintGraph(G); 
    return 0;   
}

 第2关：有向图的深度优先遍历

任务描述

本关任务：建立有向图的邻接矩阵，实现图的深度优先遍历算法。（约定：从编号小的顶点开始遍历）

相关知识

1.有向图的邻接矩阵 2.图的深度优先遍历

编程要求

实现右侧编辑栏里面的代码编写，建立有向图的邻接矩阵的建立，以及图的深度优先遍历。

输入格式

第1行：输入顶点数n和边数m 第2行：输入n个字符（表示顶点的名称） 接下来m行依次输入每条有向边

输出格式

1.有向图的邻接矩阵 2.图的深度优先序列（如图连通，则输出一行，否则分多行输出。注：每个字符前有一个空格。）

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

#define MaxInt 32767   			   //最大值
#define MVNum 20    			      //最大顶点数
typedef  struct {
   int  vexnum,arcnum;		 	   //顶点数和弧的数目 
   char vexs[MVNum]; 			   //顶点向量
   int  arcs[MVNum][MVNum];		//邻接矩阵    
}AMGraph;

int LocateVex(AMGraph G, char v) {
	int i;
	for (i = 0; i < G.vexnum; i++)
		if (G.vexs[i] == v) return i;
	return -1;
}

void CreateDG(AMGraph& G)
{//创建有向图的邻接矩阵
   /****************begin****************/
	cin >> G.vexnum >> G.arcnum;
	for (int i = 0; i < G.vexnum; i++)
		cin >> G.vexs[i];
	for (int i = 0; i < G.vexnum; i++)
	{
		for (int j = 0; j < G.vexnum; j++)
			G.arcs[i][j] = 0;
	}
	char v1, v2;
	for (int i = 0; i < G.arcnum; i++)
    {
		cin >> v1 >> v2;
        int p1 = LocateVex(G, v1);
	    int p2 = LocateVex(G, v2);
	    G.arcs[p1][p2] = 1;
    }
	
   /****************end*****************/
}
void PrintGraph(AMGraph G)       //输出图的邻接矩阵	 
{    
	cout<<"有向图的邻接矩阵：";
    for (int i=0;i<G.vexnum;i++)
	{	cout<<endl;
		for (int j=0;j<G.vexnum;j++)
		{
			printf("%5d",G.arcs[i][j]);
		}
		  
	}
}
//深度优先搜索DFS 
bool visited[MVNum];
void DFS(AMGraph G, int v)
{
    cout  << " "<< G.vexs[v]; // 访问顶点v
    visited[v] = true;        // 标记顶点v已访问

    for (int i = 0; i < G.vexnum; i++)
    {
        if (G.arcs[v][i] == 1 && !visited[i])
        {
            DFS(G, i); // 递归访问未访问的相邻顶点
        }
    }
}

void DFSTraverse(AMGraph G)
{
    for (int i = 0; i < G.vexnum; i++)
    {
        visited[i] = false; // 初始化visited数组
    }
    for (int i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            DFS(G, i);
            cout << endl; 
        }
    }
}


int main()
{
  	AMGraph G; 
  	CreateDG(G);	//建立有向图的邻接矩阵 
  	PrintGraph(G);	//输出图的邻接矩阵 
  	cout<<"\n图的深度优先序列：\n"; 
	DFSTraverse(G);
 	return 0;   
}

第3关：prim算法求最小生成树

任务描述

本关任务：编程实现无向连通网最小生成树的prim算法。

相关知识

1.无向连通网的建立 2.最小生成树的定义 3.求解最小生成树的prim算法（参见教材：P161）

编程要求

在右侧编辑栏中填写代码，实现prim算法，按步骤输出每条边，以及最小生成树的代价。

输入说明

第1行：输入顶点数n和边数m 第2行：输入n个字符（表示顶点的名称） 接下来的m行，输入每条边(u,v)，以及边上的权值。 最后输入求解最小生成树的起始顶点

输出说明

1.输出图的邻接矩阵 2.依次输出最小生成树的每条边(i,j)及其权值。3.最后输出最小生成树的代价。

#include <cstdio>
#include <iostream> 
using namespace std;
#include "graph.h"		//图的定义、无向网的建立以及输出函数 

typedef struct{
   char adjvex;
   int 	lowcost;
}node;
node closedge[MVNum];	//定义待选边辅助数组 
 
int Min(AMGraph G)
{    //从待选边辅助数组closeedge中选择最小边closedge[k]，返回k 
    int k = 0;
    while (closedge[k].lowcost == 0) {
        k++;
    }
    int minIndex = k;
    for (int i = k + 1; i < G.vexnum; i++) {
        if (closedge[i].lowcost != 0 && closedge[i].lowcost < closedge[minIndex].lowcost) {
            minIndex = i;
        }
    }
    return minIndex;
}

int MiniSpanTree(AMGraph G, char u)
{    //从顶点u出发构造最小生成树T，输出T的各条边，函数返回T的代价    
    int MSTcost=0;
    int k = LocateVex(G, u);
    for (int i = 0; i < G.vexnum; i++) {
        if (i != k) {
            closedge[i].adjvex = u;
            closedge[i].lowcost = G.arcs[k][i];
        }
    }
    closedge[k].lowcost = 0;
    for (int i = 1; i < G.vexnum; i++) {
        int minIndex = Min(G);
        cout  << "(" << closedge[minIndex].adjvex << ","<< G.vexs[minIndex] << ")" << " "<<closedge[minIndex].lowcost<< endl;
        MSTcost+=closedge[minIndex].lowcost;
        closedge[minIndex].lowcost = 0;
        
        for (int j = 0; j < G.vexnum; j++) {
            if (G.arcs[minIndex][j] < closedge[j].lowcost) {
                closedge[j].adjvex = G.vexs[minIndex];
                closedge[j].lowcost = G.arcs[minIndex][j];
            }
        }
    }
    return MSTcost;
}

int main()
{
  	AMGraph G;
	char u;
	int MSTcost;
  	CreateUDN(G);					//建立无向网的邻接矩阵
  	cin>>u;							//输入起始顶点
	PrintGraph(G);					//输出无向网 
	cout<<"\n\n最小生成树的边：\n"; 	
  	MSTcost=MiniSpanTree(G,u);		// 从顶点u出发构造最小生成树T
	cout<<"\n最小生成树的代价：\n"<<MSTcost;    	
 	return 0;   
}

第4关：Dijkstra算法求解单源点最短路径

#include <cstdio>
#include <iostream> 
using namespace std;
#include "graph.h"		//图的定义、 有向网的建立以及输出函数   

int FindMinDist(AMGraph G,int dist[],int v0)
{
    int min=MaxInt;
    int index;
    for(int i=0;i<G.vexnum;i++)
    {
        if(i!=v0 && dist[i]<min)
        {
            min=dist[i];
            index=i;
        }
    }
    return index;

}         

void ShortestPath_DIJ(AMGraph G, int v0)
{
    int dist[MVNum];
    bool visited[MVNum];

    for (int i = 0; i < G.vexnum; i++) {
        dist[i] = G.arcs[v0][i];
        visited[i] = false;
    }

    visited[v0] = true;
    dist[v0] = 0;

    for (int i = 1; i < G.vexnum; i++) 
    {
        int minDist = MaxInt, u = -1;
        for (int j = 0; j < G.vexnum; j++) 
        {
            if (!visited[j] && dist[j] < minDist)
            {
                minDist = dist[j];
                u = j;
            }
        }

        if (u == -1) break;

        visited[u] = true; 

        for (int v = 0; v < G.vexnum; v++) {
            if (!visited[v] && (dist[u] + G.arcs[u][v] < dist[v])) {
                dist[v] = dist[u] + G.arcs[u][v];
            }
        }
    }
  
    for (int i = 0; i < G.vexnum; i++) 
    {
        int index=FindMinDist(G,dist,v0);
        if(dist[index]!=MaxInt)
        {    
            cout << G.vexs[v0] << "-->" << G.vexs[index] << " " << dist[index] << endl;
            dist[index]=MaxInt;
        }
    
    }
}

int main()
{
  	AMGraph G; 
  	char u;
  	CreateDN(G);				//建立有向网的邻接矩阵 
  	cin>>u;						//输入源点
  	PrintGraph(G);				//输出有向网的邻接矩阵 
  	int v0=LocateVex(G,u);
  	cout<<"\n从顶点"<<u<<"到图中其他顶点的最短路径：\n" ;
	ShortestPath_DIJ(G,v0); 	//从顶点v0开始，应用dijkstra算法求最短路径 
 	return 0;   
}

图的邻接表实验

第1关：建立图的邻接表

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include <iostream>
using namespace std;
#define MVNum 20    			//最大顶点数

typedef  struct ArcNode {		//边结点 
    int 	adjvex;				//邻接点的位置 
    struct 	ArcNode* nextarc;	//指向下一条边的指针 
}ArcNode;

typedef struct VNode {			//表头结点（顶点信息） 
    char  data;					//顶点值 
    ArcNode* firstarc;		//指向第一条依附该顶点的边的指针 
}VNode;

typedef struct {
    int vexnum;					//图的顶点数
    int arcnum;					//图的边数 
    VNode vertices[MVNum];   	//顶点向量表 
}ALGraph;						//邻接表 

int LocateVex(ALGraph G, char v)
{//在顶点向量表中查找顶点v，如果找到，则返回顶点在图中的位置，否则返回-1
    for (int i = 0; i < G.vexnum; i++)
        if (G.vertices[i].data == v) return i;
    return -1;
}

void CreateUDG(ALGraph& G)
{//建立无向图的邻接表 , 对每一条边（i,j）,按照头插法，分别将表结点插入i表和j表  
    /******************begin*****************/
    scanf("%d %d", &G.vexnum, &G.arcnum);
    for (int i = 0; i < G.vexnum; i++)
    {
        cin >> G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    for (int i = 0; i < G.arcnum; i++)
    {
        char v1, v2;
        cin >> v1 >> v2;
        int p1 = LocateVex(G, v1);
        int p2 = LocateVex(G, v2);

        ArcNode* node1 = new ArcNode;
        node1->adjvex = p2;
        node1->nextarc = G.vertices[p1].firstarc;
        G.vertices[p1].firstarc = node1;

        ArcNode* node2 = new ArcNode;
        node2->adjvex = p1;
        node2->nextarc = G.vertices[p2].firstarc;
        G.vertices[p2].firstarc = node2;
    }




    /******************end ******************/
}
void PrintGraph(ALGraph G)				//输出图中每个点的邻接点 
{
    ArcNode* p;
    for (int i = 0; i < G.vexnum; i++)
    {
        printf("\n%2c邻接到：", G.vertices[i].data);
        for (p = G.vertices[i].firstarc; p; p = p->nextarc)
        {
            int j = p->adjvex;
            printf("%2c", G.vertices[j].data);
        }
    }
}
int main()
{
    ALGraph G;
    CreateUDG(G);				//建立无向图的邻接表 
    PrintGraph(G);				//输出图的邻接表	 
    return 0;
}

第2关：计算顶点的出度和入度

#include <cstdio>
#include <iostream>
using namespace std;
#include "graph.h"				//图的邻接表定义、有向图邻接表的建立和输出 
void FindOutdegree(ALGraph G,int outdegree[])
{ 	//计算每个顶点的出度，存入数组outdegree 
	/******************begin*****************/
   int i,j=0;
   for(i=0;i<G.vexnum;i++)
   {
       int od=0;
       ArcNode* p=G.vertices[i].firstarc;
       while(p!=NULL)
       {
           od++;
           p=p->nextarc;
       }
       outdegree[j++]=od;
   }

	/******************end *****************/   
}
void FindIndegree(ALGraph G,int indegree[])
{	//计算每个顶点的入度，存入数组indegree
   /******************begin*****************/
   int i;
   for(i=0;i<G.vexnum;i++)
   {
       ArcNode* p=G.vertices[i].firstarc;
       while(p!=NULL)
       {
           indegree[p->adjvex]++;
           p=p->nextarc;
       }

   }
   
   /******************end *****************/
}

int main()
{	ALGraph G;
	int indegree[MVNum]={0},outdegree[MVNum]; 
  	CreateDG(G);				//建立有向图的邻接表 
  	PrintGraph(G);				//输出图的邻接表
      
  	FindOutdegree(G,outdegree);	//计算每个顶点的出度 
  	cout<<"\n 顶点的出度：";
	for (int i=0;i<G.vexnum;i++) 
  		printf("%2d",outdegree[i]);

  	FindIndegree(G,indegree);	//计算每个顶点的入度 
	cout<<"\n 顶点的入度：";	
  	for (int i=0;i<G.vexnum;i++) 
  		printf("%2d",indegree[i]) ;		
	return 0;   	
}

第3关：图的广度优先遍历

#include <cstdio>
#include <iostream>
using namespace std;
#define  OK 1
#define  ERROR 0 
#define  OVERFLOW -1
typedef int Status;

#include "queue.h"              //循环队列的定义以及基本算法（初始化、入队、出队、判队空）
#include "graph.h"				//图的邻接表定义、无向图邻接表的建立和输出 
bool visited[MVNum];			//定义访问标记数组 
void BFS(ALGraph G, int v)
{
    SqQueue Q;
    InitQueue(Q);
    visited[v] = true;
    cout << " " << G.vertices[v].data;

    EnQueue(Q, v);

    while (!QueueEmpty(Q))
    {
        DeQueue(Q, v);

        for (ArcNode *p = G.vertices[v].firstarc; p; p = p->nextarc)
        {
            int w = p->adjvex;
            if (!visited[w])
            {
                visited[w] = true;
                cout << " " << G.vertices[w].data;
                EnQueue(Q, w);
            }
        }
    }
}



void BFSTraverse(ALGraph G){
   int v;
   for (v=0;v<G.vexnum;v++) 	//初始化每个顶点的访问标记为false
   		visited[v]=false;  
   for (v=0;v<G.vexnum;v++)
   {      
        if (!visited[v]) 		
		{ 
		   	cout<<endl;
        	BFS(G,v);			//对未访问的顶点v，调用BFS，进行广度优先搜索
		}
   }
	   
}//BFSTraverse

int main()
{	ALGraph G;	
  	CreateUDG(G);				//建立无向图的邻接表
	PrintGraph(G);				//输出图的邻接表
	cout<<"\n 图的广度优先序列：";	 
    BFSTraverse(G);				//广度优先遍历	
	return 0;   	
}

第4关：AOV网的拓扑排序

#include <cstdio>
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int Status;
#include "stack.h"//顺序栈的定义和基本函数的定义 
#include "graph.h"//图的邻接表定义，以及图的建立
 
void FindIndegree(ALGraph G,int indegree[]) 
{	//计算每个顶点的入度，存入数组indegree
   /*****************begin*****************/ 
  	for(int i=0;i<G.vexnum;i++)
    {
        for(ArcNode* p=G.vertices[i].firstarc;p;p=p->nextarc)
            indegree[p->adjvex]++;

    }
   /*****************end******************/ 
}

Status ToplogicalSort(ALGraph G,int topo[])
{	//利用栈保存0入度顶点，对图进行拓扑排序。如图中有环，函数返回ERROR，否则用topo数组存储拓扑序列，函数返回OK
    SqStack S;			//定义顺序栈s    	
  	InitStack(S);		//初始化空栈
	/*****************begin*****************/ 
    int indegree[MVNum]={0};
    FindIndegree(G, indegree);

    for (int i = 0; i < G.vexnum; ++i) {
        if (indegree[i] == 0) {
            Push(S, i); 
        }
    }

    int count = 0; 

    while (!StackEmpty(S)) {
        int v;
        Pop(S, v);
        topo[count++] = v;

        ArcNode* p = G.vertices[v].firstarc;
        while (p) {
            int w = p->adjvex;
            if (--indegree[w] == 0) {
                Push(S, w); 
            }
            p = p->nextarc;
        }
    }
    if (count != G.vexnum) {
        return ERROR;
    }
    return OK;                      

  	/*****************end******************/ 
}
int main()
{	ALGraph G;
	int topo[MVNum];
	CreateDG(G);							//建立有向图的邻接表 
	PrintGraph(G);							//输出图的邻接表 
  	if (ToplogicalSort(G,topo)==ERROR) 		//拓扑排序
		cout<<"\n 图中有环，拓扑排序失败！";
	else{
		cout<<"\n 拓扑序列：";
		for (int i=0;i<G.vexnum;i++)
		 	printf("%2c",G.vertices[topo[i]].data);
	} 
			
	return 0;   	
}

第5关：AOE网的关键路径

#include <cstdio>
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int Status;
#include "stack.h"						//顺序栈的定义以及栈的基本函数（初始化、入栈、出栈、判栈空） 
#include "graph.h"						//图的邻接表定义、图的建立和输出函数
int topo[MVNum],ve[MVNum],vl[MVNum];	//定义拓扑序列、事件最早发生时间和最晚发生时间 

int FindMintopo(ALGraph G,int topo[])
{
    int min=G.vexnum;
    int index;
    for(int i=0;i<G.vexnum;i++)
    {
        if(topo[i]<min)
        {
            min=topo[i];
            index=i;
        }
    }
    topo[index]=G.vexnum;
    return min;
}
void FindIndegree(ALGraph G,int indegree[]) 
{	//计算图中每个顶点的入度，存入indegree数组
    /*****************begin******************/ 
  	for(int i=0;i<G.vexnum;i++)
    {
        for(ArcNode* p=G.vertices[i].firstarc;p;p=p->nextarc)
            indegree[p->adjvex]++;
    }
    /******************end*******************/ 
}

Status ToplogicalSort(ALGraph G, int topo[]) {
    SqStack S;
    InitStack(S);

    int indegree[MVNum]={0};
    FindIndegree(G, indegree);

    int count = 0; // 

    for (int i = 0; i < G.vexnum; ++i) {
        if (indegree[i] == 0) 
            Push(S, i);
    }

    while (!StackEmpty(S)) {
        int v;
        Pop(S, v);
        topo[count++] = v;

        ArcNode* p = G.vertices[v].firstarc;
        while (p) {
            int w = p->adjvex;
            if (--indegree[w] == 0) {
                Push(S, w);
            }
            p = p->nextarc;
        }
    }

    if (count != G.vexnum) 
        return ERROR; //
    return OK;
}


void CriticalPath(ALGraph G) {
    int topo[MVNum];
    if (ToplogicalSort(G, topo) == ERROR) 
        return;

    int ve[MVNum], vl[MVNum];

    for (int i = 0; i < G.vexnum; ++i) {
        ve[i] = 0;
    }

    for (int i = 0; i < G.vexnum; ++i) {
        int v = topo[i];
        ArcNode* p = G.vertices[v].firstarc;
        while (p) {
            int w = p->adjvex;
            if (ve[v] + p->weight > ve[w]) {
                ve[w] = ve[v] + p->weight;
            }
            p = p->nextarc;
        }
    }

    for (int i = 0; i < G.vexnum; ++i) {
        vl[i] = ve[G.vexnum - 1];
    }

    for (int i = G.vexnum - 1; i >= 0; --i) {
        int v = topo[i];
        ArcNode* p = G.vertices[v].firstarc;
        while (p) {
            int w = p->adjvex;
            if (vl[w] - p->weight < vl[v]) {
                vl[v] = vl[w] - p->weight;
            }
            p = p->nextarc;
        }
    }
    cout<<endl;
    cout << " 完成工程的最短时间为：" << ve[G.vexnum - 1] << endl;
    cout << " 影响工程进度的关键活动：";

    for (int i = 0; i < G.vexnum; ++i) {
        int v = FindMintopo(G,topo);
        ArcNode* p = G.vertices[v].firstarc;
        while (p) {
            int w = p->adjvex;
            int e = ve[v];
            int l = vl[w] - p->weight;

            if (e == l) {
                cout<<endl;
                cout << " <" << G.vertices[v].data << "," << G.vertices[w].data << "> " << p->weight;
          
            }
            p = p->nextarc;
        }
    }
}


int main()
{	ALGraph G;
	CreateDN(G);							//建立AOE网（有向网）的邻接表 
	PrintGraph(G);							//输出邻接表 
  	if (ToplogicalSort(G,topo)==ERROR)
  		cout<<"\n 图中有环，工程计划不可行！";
	else 
		CriticalPath(G);					//求完成工程的最短时间，以及影响工程进度的关键活动			
	return 0;   	
}

Swallow__smile
关注
  • 13
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图结构（四）- 邻接矩阵有向图
AnndyR的专栏
01-27 1666
 一、邻接矩阵有向图的介绍 邻接矩阵有向图是指通过邻接矩阵表示的有向图。 上面的图G2包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了",,,,,,,,"共9条边。 上图右边的矩阵是G2在内存中的邻接矩阵示意图。A[i][j]=1表示第i个顶点到第j个顶点是一条边，A[i][j]=0则表示不是一条边；而A[i][j]表示的是第i行第j列的值；例如，A[1,2]=1，表示第
考研复试系列——第七节 最短路径
cassiePython的专栏
03-06 1190
考研复试系列——第七节 最短路径 前言 前面我们学习了DFS算法，利用DFS算法，我们以每一个顶点为开始节点进行DFS，最后进行比较也可以求得最短路径， 但是复杂度不能满足我们的需求。现在我们通过Floyd算法和Dijkstra算法来解决最短路径问题。 Floyd算法 Floyd算法的思想很简单，就是借助第三个点来优化另外两个顶点的距离。比如我们有三个顶点A，B，
最短路径简单应用
来自师范的学渣
03-28 813
输入：第一行输入n（表示n个节点）m（表示m条边）此后m行，每行三个数，第一个数表示出发结点，第二个数表示到达的结点，第三个数表示边权输出：输出一个数，表示从结点1出发到结点n的最短路径（若无法到达则输出Unable to reach）#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; using name...
【PTA】6-3 有向图输出出度为0顶点 (13 分)(C语言)
qq_51669241的博客
05-22 6234
6-3 有向图输出出度为0顶点 (13 分) 题目： 本题要求实现一个函数，输出有向图所有出度为0的顶点。 函数接口定义： 函数接口为： void PrintV(MGraph G); G为采用邻接矩阵作为存储结构的有向图。 裁判测试程序样例： #include <stdio.h> #define MVNum 100 //最大顶点数 typedef struct { char vexs[MVNum]; //存放顶点的一维数组 int ar
采用邻接矩阵法创建无向图和有向图
千言万语ROOM
05-24 9694
#include<stdio.h> #include<stack> #include <iostream> #define MAXSIZE 100 #define MaxInt 32767 //表示最大值，即正无穷大 #define MVNum 100 //定义最大顶点数 using namespace std; typedef char VerTexType;//假设顶点数据类型为字符型 typedef int ArcType;//假设边的权值为整型 type.
算法与数据结构实验报告——树及其应用.docx
07-12
《算法与数据结构实验报告——树及其应用》深入探讨了树这一重要的数据结构在实际问题中的应用。树因其非线性的特性，在计算机科学领域扮演着关键角色，它被广泛应用于互联网技术，例如搜索引擎的索引构建、文件系统...
北航物理实验研究性实验报告——电位差计及其应用参考.doc
09-14
电位差计及其应用是物理实验研究的重要组成部分，本文将对电位差计的原理、测量方法和应用进行详细的介绍。 一、电位差计的原理 电位差计是基于补偿原理的测量仪器，其主要原理是通过调整补偿电路中的电阻值，使得...
离散数学实验报告4——图的应用.docx
10-29
本实验报告将详细探讨图的基本概念及其应用，包括图的定义、邻接点、孤立点、邻接边、孤立边、自回路和多重边等概念，并通过矩阵表示来描述图的特性。 **1. 图的基本概念** 1.1 **图的定义**：图是离散数学中的一...
数据库原理及应用A实验报告（实验二——数据查询）
04-23
数据库原理及应用A实验报告（实验二——数据查询）详细解析 实验报告旨在让学生通过实践掌握数据库查询的基本技能，包括查询语句的编写、单表查询、连接查询、集合查询、统计查询和嵌套查询。实验环境是Windows10...
物理实验报告——光的干涉.docx
04-22
《英汉大学物理实验》实验报告。含原始数据，数据处理，作图，思考题
有向图的邻接矩阵
06-17
c语言写的有向图邻接矩阵的实现，通过使用图的邻接矩阵实现图的存储结构存储。
有向图的邻接矩阵和邻接表画法
热门推荐
qq_44667165的博客
03-27 7万+
本例子展示有向邻接表画邻接矩阵，反过来也是如此 大三时自学了了数据结构中的图，发现图中有邻接矩阵和邻接表，作为笔记记录下来 如下图所示，给了一个有向邻接表，求邻接矩阵 怎么做呢？ 第一步：和无向图类似，都是先找到你的图里面值的范围， 画出方形框，如下图所示，圆框中的值为0、1、2、3、4 第二步：从0邻接点值开始寻找与它相邻的点，遇到本身的点直接写0，箭头指向的点写上连接线上的数字，无本身箭头指向的直接写上∞ 如下图所示从0开始，能指向的只有3、7 最后：根据以上的方法依次写出1 2 3 4的邻接矩阵
有向图和无向图的表示方式(邻接矩阵，邻接表)
最新发布
weixin_69884785的博客
09-08 2万+
有向图和无向图的表示方式(邻接矩阵，邻接表)：无向图，无向网，有向图，有向网的实现
图1——用邻接矩阵表示法创建有向图
凌空的桨
04-05 1万+
图 可分两部分：一个是创建顶点信息，可用一个一维数组存储；另一个是创建弧的信息，包括弧的相关顶点和权值，可存储到二维数组里，其中，二维数组的下标分别表示两个顶点的弧尾和弧头编号，权值存放在对应的数组中。 创建一个网： 请输入有向网N的顶点数和弧数：6 9 请输入6个顶点的值： a b c d e f 请分别输入9条弧的弧尾 弧头 权值（以空格分隔）： a b 6 a e 5 a f 9 f c 7...
有向图的邻接矩阵的建立和输出
鹅鹅的博客
05-08 7341
有向图的邻接矩阵的建立和输出 算法： #include <iostream> using namespace std; #define INFINITY 65535; const int MaxVexNum =10;//最大顶点个数 typedef char VerTexData;//顶点数据类型 typedef int EdgeData;//边上权值类型 typedef struct { VerTexData VexList[MaxVexNum];//顶点表 E
邻接表法创建无向图（C语言）
SS-Clem.的博客
06-09 2万+
题目 本题要求建立一个无向图，采用邻接表做为存储结构。 例如： 输入信息为：第一行给出图的顶点数n和边数e。第二行给出n个字符，表示n个顶点的数据元素的值。后面是e行，给出每一条边的两个顶点编号。 输出每个顶点的值以及各顶点的邻接点。 输入样例： 7 9 0123456 0 2 0 3 0 4 1 3 1 5 2 3 2 5 4 5 5 6 输出样例： 0: 4 3 2 1: 5 3 2: 5 3 0 3: 2 1 0 4: 5 0 5: 6 4 2 1 6: 5 无向图还要生成对称节点 #incl
7-2 出度为0 (20 分)
m0_56184323的博客
11-21 1054
设有向图G，试找出图中出度为0的点有多少个！ 输入格式: 输入数据有多组 每组数据第一行为一个正整数vertexnum(0<vertexnum<500)，代表G的顶点数目。 接下来是有向图G的邻接矩阵！ 输出格式: 对于每组数据，请在一行里输出出度为0的顶点个数。 输入样例: 在这里给出一组输入。例如： 3 0 0 1 0 0 0 1 0 0 5 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 结尾无空行 输出样例: 在这
图的介绍和邻接矩阵、邻接表的创建（以有向图为例）
weixin_61857742的博客
03-08 3419
小编满血复活，更新力度感人~ 先让我们看看有向图长什么样吧 有向图是指节点与节点之间连线是有方向性的。 一.图的介绍 图分为有向图和无向图。 图由许多的节点组成，这些节点我们称为顶点。 有向图是指顶点之间的指向有方向性，顶点之间用<x,y>表示； 无向图的顶点之间没有单一的方向，是双向的 顶点之间用(x,y)表示。 对于两个相互连接的(不论有无方向性)顶点，它们互称邻接点。 度，分为入度和出度，入度是指指向该顶点的边个数，出度是指从这个顶点出去的边的个数，入度和出度相加就是
邻接矩阵的创建
怪咖小青年的博客
06-18 1万+
图的术语总结 开场前首先介绍一下图中的基本术语：     图的分类：有向图和无向图。无向图有顶点和边构成，有向图由顶点和弧构成（弧有分为弧尾和弧头）     图按照边或弧的多少分为稀疏图和稠密图     如果任意两个顶点之间都存在边，叫做完全图。 （有向的叫做有向完全图）     若无重复的边或顶点到自身的边，叫做简单图。     无向图顶点的边数，叫做度。有向图分为入度和出度。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值