数据结构 实验7

已于 2023-04-28 14:48:02 修改
阅读量333 收藏 1
点赞数
文章标签： 数据结构 c++ 算法
于 2023-04-28 13:27:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cariana0210/article/details/130424145
版权 
/*8647 实现图的存储结构
Description
实现有向图的邻接矩阵存储结构。
输入格式
第一行：输入图的顶点个数n（各个顶点的默认编号为1~n）， 边的条数m。
第二 ~ m+1行：每行输入两个顶点编号i、j，表示连接顶点i到顶点j的一条边。
输出格式
分n行输出n*n的邻接矩阵，表示所输入的图存储，顶点i和顶点j之间如果有边相连，则输出1，没边相连则输出0。
输入样例
4 4
1 2
1 3
3 4
4 1
输出样例
0 1 1 0
0 0 0 0
0 0 0 1
1 0 0 0*/

#include <iostream>
using namespace std;

const int N = 110;

int n, m;
int g[N][N];

int main()
{
    // 输入n和m
    cin >> n >> m;

    // 读入m条边
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        // 存储图中的边
        g[a][b] = 1;
    }

    // 输出邻接矩阵
    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= n; j ++ )
            // 输出g[i][j]
            cout << g[i][j] << ' ';
        // 换行
        cout << endl;
    }

    return 0;
}

/*8648 图的深度遍历
Description 实现图的邻接表存储结构及一些基本操作函数。在此基础上实现图的深度遍历算法并加以测试。本题只给出部分代码,请补全内容。
输入格式
第一行：输入0到3之间整数(有向图:0,有向网:1,无向图:2,无向网:3)；
第二行：输入顶点数和边数；
第三行：输入各个顶点的值（字符型，长度〈3）；(遍历从输入的第一个顶点开始)
第四行：输入每条弧(边)弧尾和弧头(以空格作为间隔),如果是网还要输入权值；
输出格式
输出对图深度遍历的结果。
输入样例
0
3 3     
a b c
a b
b c
c b
输出样例
a b c
*/
#include"string.h" 
#include"malloc.h" /* malloc()等 */ 
#include"stdio.h" /* EOF(=^Z或F6),NULL */ 
#include"stdlib.h" /* exit() */ 
typedef int InfoType; /* 顶点权值类型 */ 
#define MAX_NAME 3 /* 顶点字符串的最大长度+1 */ 
typedef char VertexType[MAX_NAME]; /* 字符串类型 */ 
/*图的邻接表存储表示 */ 
#define MAX_VERTEX_NUM 20 
typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */ 
typedef struct ArcNode 
{ 
	int adjvex; /* 该弧所指向的顶点的位置 */ 
	struct ArcNode *nextarc; /* 指向下一条弧的指针 */ 
	InfoType *info; /* 网的权值指针） */ 
}ArcNode; /* 表结点 */ 

typedef struct 
{ 
	VertexType data; /* 顶点信息 */ 
	ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */ 
}VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */ 

typedef struct 
{ 
	AdjList vertices; 
	int vexnum,arcnum; /* 图的当前顶点数和弧数 */ 
	int kind; /* 图的种类标志 */ 
}ALGraph; 

int LocateVex(ALGraph G,VertexType u) 
{ /* 初始条件: 图G存在,u和G中顶点有相同特征 */ 
/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */ 
	int i; 
	for(i=0;i<G.vexnum;++i) 
		if(strcmp(u,G.vertices[i].data)==0) 
			return i; 
	return -1; 
} 

void CreateGraph(ALGraph *G) 
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */ 
	int i,j,k; 
	int w; /* 权值 */ 
	VertexType va,vb; 
	ArcNode *p; 
	//printf("Enter the type of map:(0~3): "); 
	scanf("%d",&(*G).kind); 
	//printf("Enter Vertex number,Arc number: "); 
	scanf("%d%d",&(*G).vexnum,&(*G).arcnum); 
	//printf("Enter %d Vertex :\n",(*G).vexnum); 
	for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */ 
	{ 
		scanf("%s",(*G).vertices[i].data); 
		(*G).vertices[i].firstarc=NULL; 
	} 
	//if((*G).kind==1||(*G).kind==3) /* 网 */ 
	//	printf("Enter order every arc weight,head and tail (Takes the gap by the blank space ):\n"); 
	//else /* 图 */ 
	//	printf("Enter order every arc head and tail (Takes the gap by the blank space ):\n"); 
	for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */ 
	{ 
		scanf("%s %s", va, vb);
        i = LocateVex(*G, va);
        j = LocateVex(*G, vb);
        p = (ArcNode*)malloc(sizeof(ArcNode));
        p->adjvex = j;
        p->nextarc = (*G).vertices[i].firstarc;
        (*G).vertices[i].firstarc = p;
        if ((*G).kind == 1 || (*G).kind == 3) {
            p->info = (int*)malloc(sizeof(int));
            scanf("%d", p->info);
        }
	} 
} 

void DFS(ALGraph G, int v, int visited[]) {
    visited[v] = 1;
    printf("%s ", G.vertices[v].data);
    ArcNode* p = G.vertices[v].firstarc;
    while (p) {
        if (!visited[p->adjvex]) {
            DFS(G, p->adjvex, visited);
        }
        p = p->nextarc;
    }
}

void DFSTraverse(ALGraph G) {
    int visited[MAX_VERTEX_NUM];
    for (int i = 0; i < G.vexnum; i++) {
        visited[i] = 0;
    }
    for (int i = 0; i < G.vexnum; i++) {
        if (!visited[i]) {
            DFS(G, i, visited);
        }
    }
}

int main() {
    ALGraph G;
    CreateGraph(&G);
    DFSTraverse(G);
    return 0;
} 


/*18448 最小生成树
Description
给定结点数为n，边数为m的带权无向连通图G，所有结点编号为1,2,3....n。
求图G的最小生成树的边权和。
输入格式
第一行两个正整数n和m。n,m<=2000
之后的m行，每行三个正整数a,b,w，描述一条连接结点a和b,边权为w的边。1=<a,b<=n,w<=10^18。
注意可能存在重边和自环。
输出格式
一个整数表示图G的最小生成树的边权和（注意用长整型）。
输入样例
7 12
1 2 9
1 5 2
1 6 3
2 3 5
2 6 7
3 4 6
3 7 3
4 5 6
4 7 2
5 6 3
5 7 6
6 7 1
输出样例
16*/
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 2010, M = 4000010;

int n, m;
int h[N], e[M], ne[M], w[M], idx; // h[i]表示第i个点的所有边的编号，e[i]表示第i条边的另一个端点，ne[i]表示第i条边的下一条边的编号，w[i]表示第i条边的权重，idx表示当前边的编号
int dist[N]; // dist[i]表示第i个点到最小生成树的距离
bool st[N]; // st[i]表示第i个点是否已经在最小生成树中

void add(int a, int b, int c) // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ; // 将边的信息存储在数组中，同时更新h数组和idx
}

long long prim() // 返回最小生成树的边权和，如果图不连通则返回0x3f3f3f3f3f3f3f3f
{
    memset(dist, 0x3f, sizeof dist); // 初始化dist数组为无穷大
    long long res = 0; // 存储最小生成树的边权和

    for (int i = 0; i < n; i ++ ) // 执行n次
    {
        int t = -1; // t表示距离最小生成树最近的点
        for (int j = 1; j <= n; j ++ ) // 找到距离最小生成树最近的点
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == 0x3f3f3f3f) return 0x3f3f3f3f3f3f3f3f; // 如果t没有被更新过，说明图不连通，返回无穷大
        if (i) res += dist[t]; // 将t到最小生成树的距离加入res
        st[t] = true; // 将t加入最小生成树

        for (int j = h[t]; ~j; j = ne[j]) // 更新t的所有出边
        {
            int k = e[j]; // k表示t的一个出边的另一个端点
            if (!st[k]) dist[k] = min(dist[k], w[j]); // 如果k不在最小生成树中，更新k到最小生成树的距离
        }
    }

    return res; // 返回最小生成树的边权和
}

int main()
{
    memset(h, -1, sizeof h); // 初始化h数组为-1

    cin >> n >> m; // 输入点数和边数
    while (m -- ) // 输入每一条边
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c); // 添加双向边
    }

    cout << prim() << endl; // 输出最小生成树的边权和

    return 0;
}


/*18732 最短路问题
Description
现在有n个车站和m条直达公交线路，每条线路都有一个固定票价。
作为一个窮人，你打算从车站1坐车到车站n，请计算下车站1到车站n的最少花费。
如果车站1无法到达车站n，请输出-1。
注意，在车站x和y之间可能存在不止一条线路。
输入格式
第一行两个整数n和m，表示车站数量和线路数量。(1<=n<=100),(1<=m<=1000)
第二行至第m+1行，每行3个整数a,b,x，代表车站a和车站b之间有一条票价为x的公交线路，公交线路是双向的。
输出格式
输出车站1到n的最小花费。
输入样例
4 4
1 2 4
2 3 7
2 4 1
3 4 6
输出样例
5*/
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 110, M = 2010;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N]; // dist[i]表示1号点到i号点的最短距离
bool st[N]; // st[i]表示i号点是否已经确定最短路

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ; // 添加一条a到b的边，边权为c
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist); // 初始化，1号点到其它各个点的距离均为正无穷
    dist[1] = 0; // 1号点到1号点的距离为0

    for (int i = 0; i < n; i ++ ) // 进行n次操作
    {
        int t = -1; // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (t == -1) break; // 如果没有找到，说明剩下的点和起点不连通
        st[t] = true; // 确定一个点的最短路

        for (int j = h[t]; ~j; j = ne[j]) // 用t更新其他点的距离
        {
            int ver = e[j], distance = w[j];
            if (dist[ver] > dist[t] + distance)
                dist[ver] = dist[t] + distance; // 通过t进行松弛操作
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1; // 无法从1号点走到n号点
    return dist[n]; // 返回1号点到n号点的最短距离
}

int main()
{
    memset(h, -1, sizeof h); // 初始化邻接表

    cin >> n >> m; // n表示点数，m表示边数
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c; // 读入一条边
        add(a, b, c), add(b, a, c); // 存储无向图
    }

    cout << dijkstra() << endl; // 输出1号点到n号点的最短距离

    return 0;
}

/*
标程

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int n,m,v[105],d[105];
struct node
{
    int adj,val;
};
vector<node>e[105];
int getmin()
{
    int i,minv=999999999,mini=0;
    for(i=1; i<=n; i++)
    {
        if(v[i]==0&&minv>d[i])
        {
            mini=i;
            minv=d[i];
        }
    }
    return mini;
}
void djstra(int s)
{
    int i,j;
    memset(d,127/3,sizeof(d));
    d[s]=0;
    for(i=1; i<=n; i++)
    {
        int temp=getmin();
        v[temp]=1;
        for(j=0; j<e[temp].size(); j++) /**< e[1] 存的是2 4 5，e[1][j] 
        {
            int x=e[temp][j].adj,z=e[temp][j].val;
            if(v[x]==0&&d[x]>d[temp]+z)
            {
                d[x]=d[temp]+z;
            }
        }
    }
}
int main()
{
    ios::sync_with_stdio(0),cin.tie(0);
    int i,j,x,y,z,ans=0;
    cin>>n>>m;
    for(i=1; i<=m; i++)
    {
        cin>>x>>y>>z;
        e[x].push_back({y,z});
        e[y].push_back({x,z});
    }
    djstra(1);
    if(d[n]<1e8)
        cout<<d[n];
    else
        cout<<-1;
    return 0;
}
*/

/*8649 图的广度遍历
Description
使用图的深度遍历实现的邻接表存储结构和基本操作函数，在此基础上实现图的广度遍历算法并加以测试。注意正确使用队列存储结构。
输入格式
第一行：输入0到3之间整数(有向图:0,有向网:1,无向图:2,无向网:3)；
第二行：输入顶点数和边数；
第三行：输入各个顶点的值（字符型，长度〈3）；(遍历从输入的第一个顶点开始)
第四行：输入每条弧(边)弧尾和弧头(以空格作为间隔),如果是网还要输入权值；
输出格式
输出对图广度遍历的结果
输入样例
0
3 3
a b c
a b
b c
c b
输出样例
a b c
提示
注意题目的邻接表采用头插法，也就是后出现的边节点插入到邻接表的表头。
*/
#include"string.h"
#include"malloc.h" /* malloc()等 */
#include"stdio.h" /* EOF(=^Z或F6),NULL */
#include"stdlib.h" /* exit() */
#include <queue>

using namespace std;

typedef int InfoType; /* 顶点权值类型 */
#define MAX_NAME 3 /* 顶点字符串的最大长度+1 */
typedef char VertexType[MAX_NAME]; /* 字符串类型 */
/*图的邻接表存储表示 */
#define MAX_VERTEX_NUM 20
typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */

typedef struct ArcNode
{
	int adjvex; /* 该弧所指向的顶点的位置 */
	struct ArcNode *nextarc; /* 指向下一条弧的指针 */
	InfoType *info; /* 网的权值指针） */
}ArcNode; /* 表结点 */

typedef struct
{
	VertexType data; /* 顶点信息 */
	ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
}VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */

typedef struct
{
	AdjList vertices;
	int vexnum,arcnum; /* 图的当前顶点数和弧数 */
	int kind; /* 图的种类标志 */
}ALGraph;

int LocateVex(ALGraph G,VertexType u)
{ /* 初始条件: 图G存在,u和G中顶点有相同特征 */
/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
	int i;
	for(i=0;i<G.vexnum;++i)
		if(strcmp(u,G.vertices[i].data)==0)
			return i;
	return -1;
}

void CreateGraph(ALGraph *G)
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
	int i,j,k;
	int w; /* 权值 */
	VertexType va,vb;
	ArcNode *p;
	//printf("Enter the type of map:(0~3): ");
	scanf("%d",&(*G).kind);
	//printf("Enter Vertex number,Arc number: ");
	scanf("%d%d",&(*G).vexnum,&(*G).arcnum);
	//printf("Enter %d Vertex :\n",(*G).vexnum);
	for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
	{
		scanf("%s",(*G).vertices[i].data);
		(*G).vertices[i].firstarc=NULL;
	}
	//if((*G).kind==1||(*G).kind==3) /* 网 */
	//	printf("Enter order every arc weight,head and tail (Takes the gap by the blank space ):\n");
	//else /* 图 */
	//	printf("Enter order every arc head and tail (Takes the gap by the blank space ):\n");
	for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */
	{
		if((*G).kind==1||(*G).kind==3) /* 网 */
		scanf("%d%s%s",&w,va,vb);
		else /* 图 */
		scanf("%s%s",va,vb);
		i=LocateVex(*G,va); /* 弧尾 */
		j=LocateVex(*G,vb); /* 弧头 */
		p=(ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex=j;
		if((*G).kind==1||(*G).kind==3) /* 网 */
		{
			p->info=(int *)malloc(sizeof(int));
			*(p->info)=w;
		}
		else
		p->info=NULL; /* 图 */
		p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
		(*G).vertices[i].firstarc=p;
		if((*G).kind>=2) /* 无向图或网,产生第二个表结点 */
		{
			p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=i;
			if((*G).kind==3) /* 无向网 */
			{
				p->info=(int*)malloc(sizeof(int));
				*(p->info)=w;
			}
			else
			p->info=NULL; /* 无向图 */
			p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
			(*G).vertices[j].firstarc=p;
		}
	}
}

VertexType* GetVex(ALGraph G,int v)
{ /* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */
	if(v>=G.vexnum||v<0)
		exit(0);
	return &G.vertices[v].data;
}

int FirstAdjVex(ALGraph G,VertexType v)
{ /* 初始条件: 图G存在,v是G中某个顶点 */
/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
	ArcNode *p;
	int v1;
	v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
	p=G.vertices[v1].firstarc;
	if(p)
		return p->adjvex;
	else
		return -1;
}

int NextAdjVex(ALGraph G,VertexType v,VertexType w)
{ /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */
/* 若w是v的最后一个邻接点,则返回-1 */
	ArcNode *p;
	int v1,w1;
	v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */
	w1=LocateVex(G,w); /* w1为顶点w在图G中的序号 */
	p=G.vertices[v1].firstarc;
	while(p&&p->adjvex!=w1) /* 指针p不空且所指表结点不是w */
		p=p->nextarc;
	if(!p||!p->nextarc) /* 没找到w或w是最后一个邻接点 */
		return -1;
	else /* p->adjvex==w */
		return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */
}

int visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量),未访问标记0，访问标记1 */
void(*VisitFunc)(char* v); /* 函数变量(全局量) */

void BFSTraverse(ALGraph G,void(*Visit)(char*)) //广搜
{
    int v;
    VisitFunc=Visit;
	queue<int> Q;
    memset(visited,0,sizeof(visited));
    for(v=0;v<G.vexnum;++v)
    {
    	if(!visited[v])
    	{
    		visited[v]=1;
			Q.push(v);
			VisitFunc(G.vertices[v].data);
    		while(!Q.empty())
    		{
    			int t,w;
    			t=Q.front();
    			Q.pop();
    			for(w=FirstAdjVex(G,G.vertices[t].data);w>=0;w=NextAdjVex(G,G.vertices[t].data,G.vertices[w].data))
    			{
    				if(!visited[w])
    				{
    					visited[w]=1;
    					VisitFunc(G.vertices[w].data);
    					Q.push(w);
    				}
    			}
    		}
    	}
    }
	printf("\n");
}

void print(char *i)
{
	printf("%s ",i);
}

int main()
{
	ALGraph g;
	CreateGraph(&g);
	BFSTraverse(g,print);
	return 1;
}


/*18734 拓扑排序
在经历.....之后，你打算好好学习下计算机专业的课程，避免面试过程中的各种尴尬场面。
计算机的专业课程间既有循序渐进的特点，相互间也存在着依赖关系（似乎其他专业也是这样......）。
现在给你n门课程和m个课程间关系，请给出一个有效的学习次序。
注意可能存在多门课程不依赖任何其他课程
输入格式
第一行有2个数，分别为课程数n和关系数m。     (1=<n<=20) (1=<m<=30)
接下来有m行，每一行有2个整数a和b，表示课程b依赖于课程a。(1=<a,b<=n)
输出格式
仅一行，一个整数序列，代表课程学习次序。
为确保输出唯一性，同等条件下，编号小的在排在前面。
输入样例
6 8
1 2
1 3
1 4
3 2
3 5
4 5
6 4
6 5
输出样例
1 3 2 6 4 5*/

#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
vector<int> v[30];
int a[30],c[30];
int main()
{
    int n,m,cnt=0;
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y;
        cin>>x>>y;
        v[x].push_back(y);
        a[y]++;
    }
    priority_queue<int,vector<int>,greater<int> >q;
    for(int i=1;i<=n;i++)
    {
        if(!a[i])
            q.push(i);
    }
    while(!q.empty())
    {
        int x=q.top();
        q.pop();
        for(int i=0;i<v[x].size();i++)
        {
            a[v[x][i]]--;
            if(!a[v[x][i]])
                q.push(v[x][i]);
        }
        c[++cnt]=x;
    }
    for(int i=1;i<=cnt;i++)cout<<c[i]<<" ";
    return 0;
}

/*#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

int main()
{
    ios::sync_with_stdio(0),cin.tie(0);
    int i,j,n,m,a[25][25]= {0},d[105]= {0},x,y;
    cin>>n>>m;
    for(i=1; i<=m; i++)
    {
        cin>>x>>y;
        a[x][y]=1;
        d[y]++;
    }
    set<int>st;
    for(i=1; i<=n; i++)
        if(d[i]==0)
            st.insert(i);
    while(!st.empty())
    {
        int t=*st.begin();
        cout<<t<<' ';
        st.erase(st.begin());
        for(i=1; i<=n; i++)
        {
            if(a[t][i])
            {
                d[i]--;
                if(d[i]==0)
                    st.insert(i);
            }
        }
    }
    return 0;
}
*/



/*18747 关键路径
Description
在一个工程项目里，多项工作可以同时进行。
我们可以用有向无环图表述项目流程，把项目中的事件表述为结点，把活动表述成有权值的边。
现在我们已知项目共有n个事件，起点为1，终点为n，m个活动。
请你计算出这个项目的最早完成时间，也就是起点到收点的最长路径，即关键路径。
输入格式
第一行两个整数n和m，代表结点数量和边数量。(1<=n,m<=100)
下面m行，每行3个整数a,b,x,表示点a到点b之间有一条长度为x的有向边。
输出格式
一个整数，起点到终点的最长路径.
输入样例
4 6
1 2 3
1 3 2
1 4 3
2 3 3
2 4 5
3 4 3
输出样例
9*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>

using namespace std;

int n,m,d[1005]= {0},e[1005][1005],dp[1005]; //dp动态规划

int main()
{
    cin >> n >> m;
    int i,x,y,z;
    for(i=1; i<=m; i++)
    {
        cin >> x >> y >> z;
        e[x][y]=z;//构建邻接矩阵，赋权值
        d[y]++;//入度数+1
    }
    queue<int>q;
    for(i=1; i<=n; i++)
    {
        if(d[i]==0)//如果入度数为0
            q.push(i);//入队
    }
    while(q.size())
    {
        int t=q.front();//取队头元素
        //cout << t << ' ';
        q.pop();//弹出
        for(i=1; i<=n; i++) //n个顶点
        {
            if(e[t][i])
            {
                dp[i]=max(dp[i],dp[t]+e[t][i]);//求从点1到点i的最长路径
                d[i]--;//入度数-1
                if(d[i]==0)//如果入度数为0
                    q.push(i);//入队
            }
        }
    }
    cout << dp[n];//输出从起点1到终点n的最长路径
    return 0;
}

/*
标程

#include <iostream>
#include <queue>
using namespace std;
int n,m,a[105][105],v[1005],d[1005],dis[1005];
int main()
{
    ios::sync_with_stdio(0),cin.tie(0);
    int i,j,x,y,z;
    cin>>n>>m;
    for(i=1; i<=m; i++)
    {
        cin>>x>>y>>z;
        a[x][y]=z;
        d[y]++;
    }
    queue<int>q;
    q.push(1);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        for(i=1; i<=n; i++)
        {
            if(a[t][i])
            {
                d[i]--,dis[i]=max(dis[i],dis[t]+a[t][i]);
                if(d[i]==0)
                    q.push(i);
            }
        }
    }
    cout<<dis[n];
    return 0;
}
*/

Cariana0210
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】实验七 图
兔子王
11-29 859
【实验内容】1.编写程序，实现图的邻接矩阵存储及图的深度优先搜索和广度优先搜索。2.编写程序，实现图的邻接表存储和拓扑排序算法。3.编写程序，实现带权图的存储、图的最小生成树及单源最短路径算法。4.编写程序，实现最小生成树的Kruskal算法。
数据结构实验六
panlxg的博客
06-01 1823
实验 6：图的实验 1              -图的邻接矩阵存储实现一、实验目的 1、 熟练理解图的相关概念；2、 掌握图的邻接矩阵的存储方法的实现； 3、 学会图的遍历算法 二、实验内容 1、自己确定一个简单无向图（顶点数、和相关结点信息）利用邻接矩阵来实现存储。实现 图的构造，并完成：  1） 用深度优先和广度优秀两种算法对图进行遍历，输出顶点序列数据；2） 以合理的格式，输出各个顶点的邻...
《数据结构》实验报告七：查找
热门推荐
Amentos的博客
11-30 1万+
《数据结构》实验报告：查找相关概念 + 顺序查找算法 + 折半查找算法 + 开放地址法构造并查找哈希表 算法代码
数据结构：实验七：数据查找
最新发布
菜鸟的博客~
04-25 990
（1）编写一个程序exp8-1.cpp, 按提示输入10个任意的整形数据（无序），再输入一个待查找的数据，采用顺序查找方法，如果查找成功，返回该数据所在的位置（逻辑序号）。如果查找不成功，给出一定的提示。（2）编写一个程序exp8-2.cpp,输出在顺序表(1,2,3,4,5,6,7,8,9,10)中采用折半查找方法查找关键字9的过程。Windows+DEV C++( 或者其他编译工具)（1）领会各种查找算法的过程和算法设计。3.主程序设计及完成实验要求中的功能。（2）掌握查找算法解决实际问题。
#头歌 数据结构 实验七 二叉树的建立及应用
千浔的博客
01-01 2040
二叉树或者是一棵空树。或者是一棵由一个根结点和两棵互不相交的分别称做根结点的左子树和右子树所组成的非空树，左子树和右子树又同样都是一棵二叉树。度为2的树至少有3个结点，而二叉树的结点数可以为0。度为2的树不区分子树的次序，而二叉树中的每个结点最多有两个孩子结点，且必须要区分左右子树，即使在结点只有一棵子树的情况下也要明确指出该子树是左子树还是右子树。
7-1 有向图的拓扑序列
2203_75646004的博客
11-24 596
输出有向图的拓扑序列。
数据结构7
的博客
08-21 158
1.愿天下有情人都是失散多年的兄妹 #include <bits/stdc++.h> using namespace std; const int maxn=1e6+10; int fa[maxn],mom[maxn],vis[maxn]; char sex[maxn]; int flag=1; void dfs(int id,int color,int cnt) { if (cnt>5||id==-1||!flag) { return; }
数据结构试验.7z数据结构试验.7z
06-09
在“数据结构试验.7z”这个压缩包中，我们可以推测它包含了与数据结构相关的实验或项目文件，可能包括源代码、文档、测试数据等。下面将详细解释数据结构的一些关键知识点。 首先，数据结构主要分为两大类：线性...
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
数据结构实验一.rar
04-29
1.建立一个顺序表，随机产生10个100以内的整数，并按要求完成:(1）编写...2.有两个有序排序的单链表Ll和L2，分别存放10个数据元素，设计算法实现两个单链表的合并，要求合并后的单链表仍然有序排序，并输出合并结果。
山东大学软件学院数据结构实验七图的操作
12-28
1、 创建图类，存储结构使用邻接矩阵。 2、 输入图的节点数n（不超过10个）、边数m，节点分别用1-n代表。 3、 采用“起始节点，终止节点，权值”输入图的m条边，创建图。 4、 输出从节点1开始的BFS遍历，要求小的节点在前大的在后。 5、 输出从节点1开始的DFS遍历，要求小的节点在前大的在后。 6、 输出从第1节点到第n节点最短路径的长度，如果没有路经，输出0。
北京科技大学数据结构实验
11-27
北京科技大学为计算机科学与技术专业的大二学生提供了丰富的数据结构实验，旨在帮助他们深入理解理论知识，并通过实践提升编程技能。 实验报告-计140.doc可能包含了整个实验课程的概述、实验目的、实验环境、实验...
数据结构实验报告答案.pdf
08-22
数据结构实验报告答案
2020/10/29有向图的拓扑序列
lsw518598的博客
10-29 672
有向图的拓扑序列-bfs的应用题目题目分析变量说明源代码备注说明 题目 给定一个n个点m条边的有向图，点的编号是1到n，图中可能存在重边和自环。 请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出-1。 若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。 输入格式 第一行包含两个整数n和m 接下来m行，每行包含两个整数x和y，表示存在一条从点x到点y的有向边(x, y)。 输出格式 共一行，如果存在拓扑序列，则输出任意一
有向图的拓扑序列
goto_1600的博客
02-10 828
题目： 给定一个n个点m条边的有向图，图中可能存在重边和自环。 请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出-1。 若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。 输入格式 第一行包含两个整数n和m 接下来m行，每行包含两个整数x和y，表示存在一条从点x到点y的有向边(x, y)。 输出格式 共一行，如果存在拓...
数据结构 实验7 二叉树的应用
qq_52008568的博客
10-21 923
实验7 二叉树的应用 （1）实验目的 通过该实验，使学生理解二叉树的链式存储，掌握二叉树的几种遍历算法，并通过该实验使学生理解递归的含义，掌握C语言编写递归函数的方法和注意事项。 （2）实验内容 实现教材中算法6.4描述的二叉树创建算法，在此基础上实现二叉树的先序、后序递归遍历算法、两种非递归中序遍历、层序遍历、求二叉树的深度。注意：在非递归算法中用到栈和队列时，不要调用系统的栈和队列，需要自己实现栈和队列的操作。 （3）参考界面 （4）验收/测试用例  创建 输入 ：ABCKaTeX parse er
图子系统
05-13 1029
图子系统 1.实验目的 （1）掌握图邻接矩阵的存储方法。 （2）掌握图深度优先遍历的基本思想。 （3）掌握图广度优先遍历的基本思想。 2.实验内容 （1）编写按键盘输入的数据建立图的邻接矩阵存储。 （2）编写图的深度优先遍历函数。 （3）编写图的广度优先遍历函数。 （4）设计一个选择式菜单如下： 图 ...
数据结构实验课：实验七、查找算法的实现
listboy的博客
05-19 1万+
实验七、查找算法的实现 一、实验目的 掌握顺序和二分查找算法的基本思想及其实现方法。 二、实验要求 问题描述：对给定的任意数组（设其长度为n），分别用顺序和二分查找方法在此数组中查找与给定值k相等的元素。 顺序查找基本思想：从查找表的一端开始，逐个将记录的关键字值和给定值进行比较，如果某个记录的关键字值和给定值相等，则称查找成功；否则，说明查找表中不存在关键字值为给定值的记录，则称查找失败。 二分查找基本思想：先取查找表的中间位置的关键字值与给定关键字值作比较，若它们的值相等，则查找成功；如果给定值比该记录

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值