SDUT OJ----数据结构----图论习题

最新推荐文章于 2022-08-14 10:39:54 发布
最新推荐文章于 2022-08-14 10:39:54 发布
阅读量552 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 图搜索算法 深度优先 广度优先 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55812984/article/details/119809030
版权

A - 数据结构实验之图论一：基于邻接矩阵的广度优先搜索遍历

Description

给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历）

Input

输入第一行为整数n（0< n <100），表示数据的组数。
对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ t＜k），表示有m条边，k个顶点，t为遍历的起始顶点。
下面的m行，每行是空格隔开的两个整数u，v，表示一条连接u，v顶点的无向边。

Output

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示BFS的遍历结果。

Sample

Input 

1
6 7 0
0 3
0 4
1 4
1 5
2 3
2 4
3 5

Output 

0 3 4 2 5 1

Hint

以邻接矩阵作为存储结构。

简单存储领接矩阵实现

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int map[101][101];
int ans[101];
int temp[101];
int k = 0;

void BFS(int n)
{
    int front,rear,start;
    front = rear = 0;
    ans[n]=1;
    temp[rear++] = n;
    while(rear>front){
        start = temp[front++];
        for(int i=0;i<k;i++){
            if(!ans[i] && map[start][i]){
                ans[i] = 1;
                temp[rear++] = i;
            }
        }
    }
}

int main()
{
    int t,m,T,x,y;
    scanf("%d",&T);
    while(T--){
        memset(map,0,sizeof(map));
        memset(temp,0,sizeof(temp));
        memset(ans,0,sizeof(ans));
        scanf("%d%d%d",&k,&m,&t);
        for(int i=0;i<m;i++){
            scanf("%d%d",&x,&y);
            map[x][y]=1;
            map[y][x]=1;
        }
        BFS(t);
        for(int i=0;i<k;i++){
            if(i<k-1){
                printf("%d ",temp[i]);
            }
            else{
                printf("%d\n",temp[i]);
            }
        }
    }
    return 0;
}

正规邻接矩阵做法

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define INF INT_MAX
#define MAXVEX 30

typedef char  vertextype[10];

typedef struct vertex
{
    int adjvex;
    vertextype data;
}Vtype;

typedef struct graph
{
    int n;
    int e;
    Vtype vexs[MAXVEX];
    int edges[MAXVEX][MAXVEX];
}Mgraph;

void creategraph(Mgraph &g,int map[][MAXVEX],int n1,int n2)
{
    g.n = n1;
    g.e = n2;
    for(int i=0;i<g.n;i++){
        for(int j=0;j<g.n;j++){
            g.edges[i][j] = map[i][j];
        }
    }
}

void BFS(Mgraph &g,int t)
{
    int rear,front,start,vis[MAXVEX];
    rear=front= 0;
    for(int i=0;i<MAXVEX;i++){
    	vis[i] = 0;
	}
    vis[t] = 1;
    g.vexs[rear++].adjvex = t;
    while(rear>front){
        start = g.vexs[front++].adjvex;
        for(int i=0;i<g.n;i++){
            if(!vis[i] && g.edges[start][i]==1){
                vis[i] = 1;
                g.vexs[rear++].adjvex = i;
            }
        }
    }
}

int main()
{
    int T,n,e,t,x,y;
    int map[MAXVEX][MAXVEX];
    scanf("%d",&T);
    while(T--){
        Mgraph g;
        scanf("%d%d%d",&n,&e,&t);
        for(int i=0;i<e;i++){
            scanf("%d%d",&x,&y);
            map[x][y] = 1;
            map[y][x] = 1;
        }
        creategraph(g,map,n,e);
        BFS(g,t);
        for(int i=0;i<g.n;i++){
            if(i<g.n-1){
                printf("%d ",g.vexs[i].adjvex);
            }
            else{
                printf("%d\n",g.vexs[i].adjvex);
            }
        }
    }
    return 0;
}

数据结构实验之图论二：基于邻接表的广度优先搜索遍历

Description

给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历）

Input

输入第一行为整数n（0< n <100），表示数据的组数。
对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ t＜k），表示有m条边，k个顶点，t为遍历的起始顶点。
下面的m行，每行是空格隔开的两个整数u，v，表示一条连接u，v顶点的无向边。

Output

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示BFS的遍历结果。

Sample

Input 

1
6 7 0
0 3
0 4
1 4
1 5
2 3
2 4
3 5

Output 

0 3 4 2 5 1

Hint

用邻接表存储。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define INF INT_MAX
#define MAXVEX 10
int temp[MAXVEX];
int top = 0;

typedef struct edgenode
{
    int adjvex;/*相邻点序号*/
    int weight;/*边的权值*/
    edgenode *nextarc;/*下一条边的信息*/
}ArcNode;/*边结点类型*/

typedef struct vexnode
{
    int data;/*顶点的信息*/
    ArcNode *firstarc;/*头结点，指向第一条边结点*/
}VheadNode;/*头结点类型*/

typedef struct graph
{
    int vernums;
    int edgenums;
    VheadNode adjlist[MAXVEX];/*单链表头结点数组*/
}Mgraph;

void creategraph(Mgraph &G,int n1,int n2)
{
	int u,v;
    G.vernums = n1;
    G.edgenums = n2;
	for(int i=0;i<G.vernums;i++){
        G.adjlist[i].data = i;
        G.adjlist[i].firstarc=NULL;
    }
    ArcNode *s,*p;
    for(int i=0;i<G.edgenums;i++){
        scanf("%d%d",&u,&v);
        s=(ArcNode*)malloc(sizeof(ArcNode));
        s->adjvex=v;
        p=G.adjlist[u].firstarc;
        if(!p){
            s->nextarc = NULL;
            G.adjlist[u].firstarc = s;
    	}
        else{
            while(p->nextarc){
            p=p->nextarc;
        }
        s->nextarc = p->nextarc;   
        p->nextarc = s;
        }
        s=(ArcNode*)malloc(sizeof(ArcNode));
        s->adjvex=u;
        p=G.adjlist[v].firstarc;
        if(!p){
        	s->nextarc = NULL;
    		G.adjlist[v].firstarc = s;
        }
        else{
            while(p->nextarc){
                p=p->nextarc;
            }
            s->nextarc = p->nextarc;
            p->nextarc = s;
        }
    }
}

void BFS(Mgraph &g,int t)
{
    ArcNode *p;
    int front,rear,start;
    int vis[MAXVEX],Queue[MAXVEX];
    front = rear = 0;
    for(int i=0;i<MAXVEX;i++){
    	vis[i] = 0;
	} 
	vis[t] = 1;
    temp[top++] = t;
    Queue[rear++]=t;
    while(front!=rear)
    {
        int f,i;
        start = Queue[front++];
        p=g.adjlist[start].firstarc;
        while(p!=NULL)
        {
            if(!vis[p->adjvex])
            {
                vis[p->adjvex]=1;
                temp[top++] = p->adjvex;
                Queue[rear++]=p->adjvex;
            }
            p=p->nextarc;
        }
    }
}

int main()
{
    int n,t,k,m;
    scanf("%d",&n);
    while(n--)
    {
        top = 0;
        Mgraph G;
        scanf("%d%d%d",&k,&m,&t);
        creategraph(G,k,m);
        BFS(G,t);
        for(int i=0;i<top;i++){
        	if(i<top-1){
        		printf("%d ",temp[i]);
			}
			else{
				printf("%d\n",temp[i]);
			}
		}
    }
    return 0;
}

B - 数据结构实验之图论二：图的深度遍历

Description

请定一个无向图，顶点编号从0到n-1，用深度优先搜索(DFS)，遍历并输出。遍历时，先遍历节点编号小的。

Input

输入第一行为整数n（0 < n < 100），表示数据的组数。 对于每组数据，第一行是两个整数k,m（0 ＜ k ＜ 100，0 ＜ m ＜ k*k），表示有m条边，k个顶点。 下面的m行，每行是空格隔开的两个整数u，v，表示一条连接u，v顶点的无向边。

Output

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示DFS的遍历结果。

Sample

Input 

1
4 4
0 1
0 2
0 3
2 3

Output 

0 1 2 3
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int map[101][101];
int ans[101];
int temp[101];
int count = 0;
int k = 0;

void DFS(int n)
{
	ans[n] = 1;
	temp[count++] = n;
	for(int i=0;i<k;i++){
		if(!ans[i] && map[n][i]){
			DFS(i);
		}
	}
}

int main()
{
	int T,m,x,y;
	scanf("%d",&T);
	while(T--){
		memset(map,0,sizeof(map));
		memset(ans,0,sizeof(ans));
		memset(temp,0,sizeof(temp));
		count = 0;
		scanf("%d%d",&k,&m);
		for(int i=0;i<m;i++){
			scanf("%d%d",&x,&y);
			map[x][y]=1;
			map[y][x]=1;
		}
		DFS(0);
		for(int i=0;i<count;i++){
			if(i<count-1){
				printf("%d ",temp[i]);
			}
			else{
				printf("%d\n",temp[i]);
			}
		}
	}
	return 0;
}

数据结构实验之图论三：判断可达性

Description

 在古老的魔兽传说中，有两个军团，一个叫天灾，一个叫近卫。在他们所在的地域，有n个隘口，编号为1..n，某些隘口之间是有通道连接的。其中近卫军团在1号隘口，天灾军团在n号隘口。某一天，天灾军团的领袖巫妖王决定派兵攻打近卫军团，天灾军团的部队如此庞大，甚至可以填江过河。但是巫妖王不想付出不必要的代价，他想知道在不修建任何通道的前提下，部队是否可以通过隘口及其相关通道到达近卫军团展开攻击。由于n的值比较大（n<=1000），于是巫妖王找到了擅长编程的你 =_=，请你帮他解决这个问题，否则就把你吃掉变成他的魔法。为了拯救自己，赶紧想办法吧。

Input

 输入包含多组，每组格式如下。

第一行包含两个整数n,m（分别代表n个隘口，这些隘口之间有m个通道）。

下面m行每行包含两个整数a，b；表示从a出发有一条通道到达b隘口（注意：通道是单向的）。

Output

 如果天灾军团可以不修建任何通道就到达1号隘口，那么输出YES，否则输出NO。

Sample

Input 

2 1
1 2
2 1
2 1

Output 

NO
YES

DFS做法

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int map[1001][1001];
int ans[1001];
int flag = 0;
int k = 0;

void DFS(int n)
{
	ans[n] = 1;
	if(n==1){
		flag = 1;
	}
	for(int i=1;i<=k;i++){
		if(!ans[i] && map[n][i]){
			DFS(i);
		}
	}
}

int main()
{
	int m,x,y;
	while(scanf("%d%d",&k,&m)!=EOF){
		memset(map,0,sizeof(map));
		memset(ans,0,sizeof(ans));
		flag = 0;
		for(int i=0;i<m;i++){
			scanf("%d%d",&x,&y);
			map[x][y]=1;
		}
		DFS(k);
		if(flag){
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	return 0;
}

BFS做法

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int map[1001][1001];
int ans[1001];
int flag=0;
int temp[1001];
int k = 0;

void BFS(int t)
{
	int front,rear,start;
	front=rear=0;
	ans[t] = 1;
	temp[rear++] = t;
	while(rear>front){
		start = temp[front++];
		if(start==1){
			flag = 1;
		}
		for(int i=1;i<=k;i++){
			if(!ans[i] && map[start][i]){
				ans[i] = 1;
				temp[rear++]=i;
			}
		}
	}
}

int main()
{
	int m,x,y;
	while(scanf("%d%d",&k,&m)!=EOF){
		memset(map,0,sizeof(map));
		memset(ans,0,sizeof(ans));
		memset(temp,0,sizeof(temp));
		flag = 0;
		for(int i=0;i<m;i++){
			scanf("%d%d",&x,&y);
			map[x][y]=1;
		}
		BFS(k);
		if(flag){
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	return 0;
}

D - 数据结构实验之图论四：迷宫探索

Description

有一个地下迷宫，它的通道都是直的，而通道所有交叉点(包括通道的端点)上都有一盏灯和一个开关；请问如何从某个起点开始在迷宫中点亮所有的灯并回到起点？

Input

连续T组数据输入，每组数据第一行给出三个正整数，分别表示地下迷宫的结点数N(1 < N <= 1000)、边数M(M <= 3000)和起始结点编号S，随后M行对应M条边，每行给出一对正整数，表示一条边相关联的两个顶点的编号。

Output

若可以点亮所有结点的灯，则输出从S开始并以S结束的序列，序列中相邻的顶点一定有边，否则只输出部分点亮的灯的结点序列，最后输出0，表示此迷宫不是连通图。
访问顶点时约定以编号小的结点优先的次序访问，点亮所有可以点亮的灯后，以原路返回的方式回到起点。

Sample

Input 

1
6 8 1
1 2
2 3
3 4
4 5
5 6
6 4
3 6
1 5

Output 

1 2 3 4 5 6 5 4 3 2 1

Hint

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int map[1001][1001];
int vis[1001];
int ans[1001];
int k,m,threadmbcinfostruct;
int count;

void DFS(int n)
{
    vis[n] = 1;
    ans[count++] = n;
    for(int i=1;i<=k;i++){
        if(!vis[i] && map[n][i]){
            DFS(i);
            ans[count++] = n;
        }
    }
}

int main()
{
    int T,x,y,t;
    scanf("%d",&T);
    while (T--)
    {
        memset(map,0,sizeof(map));
        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));
        count = 0;
        scanf("%d%d%d",&k,&m,&t);
        for(int i=0;i<m;i++){
            scanf("%d%d",&x,&y);
            map[x][y] = 1;
            map[y][x] = 1;
        }
        DFS(t);
        for(int i=0;i<count;i++){
            printf("%d ",ans[i]);
        }
        if(count==2*k-1){
            printf("\n");
        }
        else{
            printf("0\n");
        }
    }

    return 0;
}

数据结构实验之图论五：从起始点到目标点的最短步数（BFS）

Description

 在古老的魔兽传说中，有两个军团，一个叫天灾，一个叫近卫。在他们所在的地域，有n个隘口，编号为1..n，某些隘口之间是有通道连接的。其中近卫军团在1号隘口，天灾军团在n号隘口。某一天，天灾军团的领袖巫妖王决定派兵攻打近卫军团，天灾军团的部队如此庞大，甚至可以填江过河。但是巫妖王不想付出不必要的代价，他想知道在不修建任何通道的前提下，部队是否可以通过隘口及其相关通道到达近卫军团展开攻击；如果可以的话，最少需要经过多少通道。由于n的值比较大（n<=1000），于是巫妖王找到了擅长编程的你 =_=，请你帮他解决这个问题，否则就把你吃掉变成他的魔法。为了拯救自己，赶紧想办法吧。

Input

 输入包含多组，每组格式如下。

第一行包含两个整数n,m（分别代表n个隘口，这些隘口之间有m个通道）。

下面m行每行包含两个整数a，b；表示从a出发有一条通道到达b隘口（注意：通道是单向的）。

Output

 如果天灾军团可以不修建任何通道就到达1号隘口，那么输出最少经过多少通道，否则输出NO。

Sample

Input 

2 1
1 2
2 1
2 1

Output 

NO
1
#include<stdio.h>
#include<string.h>
#define MAXSIZE 1001
int map[MAXSIZE][MAXSIZE];
int n,m;

void BFS(int n)
{
    int vis[MAXSIZE],queue[MAXSIZE],step[MAXSIZE];
    int rear,front,start;
    int top = 0;
    for(int i=0;i<n;i++){
        vis[i] = 0;
    }
    rear = front = 0;
    vis[n] = 1;
    step[n] = 0;
    queue[rear++] = n;
    while(rear>front){
        start = queue[front++];
        for(int i=1;i<=n;i++){
            if(!vis[i] && map[start][i]==1){
                vis[i] = 1;
                step[i] = step[start]+1;
                queue[rear] = i;
                if(queue[rear]==1){
                	printf("%d\n",step[1]);
                	return;
                }
                else{
                	rear++;
				}
            }
        }
    }
    printf("NO\n");
}

int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF){
    	memset(map,0,sizeof(map));
        for(int i=0;i<m;i++){
            scanf("%d%d",&u,&v);
            map[u][v] = 1;
        }
        BFS(n);
    }
    return 0;
}

数据结构实验之图论六：村村通公路

Description

当前农村公路建设正如火如荼的展开，某乡镇政府决定实现村村通公路，工程师现有各个村落之间的原始道路统计数据表，表中列出了各村之间可以建设公路的若干条道路的成本，你的任务是根据给出的数据表，求使得每个村都有公路连通所需要的最低成本。

Input

连续多组数据输入，每组数据包括村落数目N(N <= 1000)和可供选择的道路数目M(M <= 3000)，随后M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个村庄的编号和修建该道路的预算成本，村庄从1～N编号。 

Output

输出使每个村庄都有公路连通所需要的最低成本，如果输入数据不能使所有村庄畅通，则输出-1，表示有些村庄之间没有路连通。 

Sample

Input 

5 8
1 2 12
1 3 9
1 4 11
1 5 3
2 3 6
2 4 9
3 4 4
4 5 6

Output 

19

Hint

prim算法

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXVEX 3001
#define INF 9999999

int map[MAXVEX][MAXVEX];

void prim(int n)
{
    int mst[MAXVEX],lowcost[MAXVEX];
    int pos,min,sum;
    for(int i=2;i<=n;i++){
        lowcost[i] = map[1][i];
        mst[i] = 1;
    }
    sum = 0;
    mst[1] = 0;
    for(int i=2;i<=n;i++){
        min = INF;
        for(int j=2;j<=n;j++){
            if(lowcost[j] && lowcost[j]<min){
                min = lowcost[j];
                pos = j;
            }
        }
        if(min==INF){
            printf("-1\n");
            return;
        }
        else{
            sum+=min;
        }
        lowcost[pos] = 0;
        for(int j=2;j<=n;j++){
            if(map[pos][j]<lowcost[j]){
                lowcost[j] = map[pos][j];
                mst[j] = pos;
            }
        }
    }
    printf("%d\n",sum);
}

int main()
{
    int n,m,a,b,c;
    while (scanf("%d%d",&n,&m)!=EOF){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                map[i][j] = INF;
            }
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a,&b,&c);
            map[a][b] = c;
            map[b][a] = c;
        }
        prim(n);
    }
    return 0;
}

Kruskal算法 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXSIZE 3001

typedef struct node
{
    int x;
    int y;
    int data;
}Node;

Node map[MAXSIZE];
int pre[MAXSIZE];
int vexs,edges;

void sort(Node map[])
{
    for(int i=1;i<=edges-1;i++){
        for(int j=1;j<=edges-i;j++){
            if(map[j].data>map[j+1].data){
                Node t;
                t = map[j];
                map[j] = map[j+1];
                map[j+1] = t;
            }
        }
    }
}

void init(int n)
{
    for(int i=1;i<=n;i++){
        pre[i] = i;
    }
}

int findroot(int i)
{
    if(pre[i] == i)
        return pre[i];
    else
    {
        pre[i] = findroot(pre[i]);
        return pre[i];
    }
}

int Union(int u, int v)
{
    int t1 = findroot(u), t2 = findroot(v);
    if(t1 != t2)
    {
        pre[t1] = pre[t2];
        return 1;
    }
    else
        return 0;
}


void Kruskal()
{
    int sum,num,u,v,flag;
    sum = num = flag = 0;
    init(vexs);
    sort(map);
    for(int i=1;i<=edges;i++){
    	if(Union(map[i].x,map[i].y)){
    		sum+=map[i].data;
	    }
	}
	for(int i=1;i<=vexs;i++){
		if(i==pre[i]){
			flag++;
		}
	}
	if(flag==1){
		printf("%d\n",sum);
	}
	else{
		printf("-1\n");
	}
}

int main()
{
    while (scanf("%d%d",&vexs,&edges)!=EOF)
    {
        for(int i=1;i<=edges;i++){
            scanf("%d%d%d",&map[i].x,&map[i].y,&map[i].data);
        }
        Kruskal(); 
    }
    return 0;
}

J - 数据结构实验之图论十：判断给定图是否存在合法拓扑序列

Description

 给定一个有向图，判断该有向图是否存在一个合法的拓扑序列。

Input

 输入包含多组，每组格式如下。

第一行包含两个整数n，m，分别代表该有向图的顶点数和边数。(n<=10)

后面m行每行两个整数a b，表示从a到b有一条有向边。

Output

 若给定有向图存在合法拓扑序列，则输出YES；否则输出NO。

Sample

Input 

1 0
2 2
1 2
2 1

Output 

YES
NO

邻接矩阵简单做法

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXVEX 21

int map[MAXVEX][MAXVEX];
int in[MAXVEX];

void TopSort(int n)
{
	int queue[MAXVEX];
    int count,rear,front,top;
    count = rear = front =0;
    for(int i=1;i<=n;i++){
        if(!in[i]){
            queue[rear++] = i;
        }
    }
    while(rear>front){
        top = queue[front++];
        count++;
        for(int i=1;i<=n;i++){
            if(map[top][i]){
                in[i]--;
                if(!in[i]){
                    queue[rear++]=i;
                }
            }
        }
    }
    if(count==n){
        printf("YES\n");
    }
    else{
        printf("NO\n");
    }
}

int main()
{
    int u,v,n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
    	memset(map,0,sizeof(map));
    	memset(in,0,sizeof(in));
        for(int i=1;i<=m;i++){
            scanf("%d%d",&u,&v);
            map[u][v] = 1;
            map[u][v]=map[v][u] = 1;
            in[v]++;
        }
        TopSort(n);
    }
}

 邻接表做法2，存在一些BUG，找半天没找出来，当MAXVEX为10时可以输出，变为其它数就不能输出了，非常诡异。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXVEX 10
typedef struct edgenode
{
    int adjvex;
    int weight;
    edgenode *nextarc;
}ArcNode;

typedef struct vexnode
{
    int data;
    int count;
    ArcNode *firstarc;
}VheadNode;

typedef struct graph
{
    int vernums;
    int edgenums;
    VheadNode adjlist[MAXVEX];
}Mgraph;

void creategraph(Mgraph &G,int n1,int n2)
{
	int u,v;
    G.vernums = n1;
    G.edgenums = n2;
	for(int i=0;i<G.vernums;i++){
        G.adjlist[i].data = i;
        G.adjlist[i].firstarc=NULL;
    }
    ArcNode *s,*p;
    for(int i=0;i<G.edgenums;i++){
        scanf("%d%d",&u,&v);
        s=(ArcNode*)malloc(sizeof(ArcNode));
        s->adjvex=v;
        p=G.adjlist[u].firstarc;
        if(!p){
            s->nextarc = NULL;
            G.adjlist[u].firstarc = s;
    	}
        else{
            while(p->nextarc){
           		p=p->nextarc;
        	}
        	s->nextarc = p->nextarc;   
        	p->nextarc = s;
        }
    }
}

void TopSort(Mgraph *g)
{
    int top,u,v,num;
    int stack[MAXVEX];
    ArcNode *p;
    p = NULL;
    top = -1;
    num = 0;
    for(int i=0;i<g->vernums;i++){
    	g->adjlist[i].count = 0;
	}
    for(int i=0;i<g->vernums;i++){
        p=g->adjlist[i].firstarc;
        while(p!=NULL){
            g->adjlist[p->adjvex].count++;
            p=p->nextarc;
        }
    }
    for(int i=0;i<g->vernums;i++){
        if(g->adjlist[i].count==0){
            stack[++top] = i;
        }
    }
    while(top>-1){
        u = stack[top--];
        num++;
        p = g->adjlist[u].firstarc;
        while(p){
            v = p->adjvex;
            g->adjlist[v].count--;
            if(g->adjlist[v].count==0){
                stack[++top] = v;
                num++;
            }
            p = p->nextarc;
        }
    }
    if(num==g->vernums){
    	printf("YES\n");
	}
	else{
		printf("NO\n");
	}
}

int main()
{
	int n,m;
	Mgraph g;
	while(scanf("%d%d",&n,&m)!=EOF){
		creategraph(g,n,m);
		TopSort(&g);
	}
	return 0;
}

M - 数据结构实验之图论十一：AOE网上的关键路径

Description

    一个无环的有向图称为无环图（Directed Acyclic Graph），简称DAG图。
    AOE(Activity On Edge)网：顾名思义，用边表示活动的网，当然它也是DAG。与AOV不同，活动都表示在了边上，如下图所示：
                                     


    如上所示，共有11项活动（11条边），9个事件（9个顶点）。整个工程只有一个开始点和一个完成点。即只有一个入度为零的点（源点）和只有一个出度为零的点（汇点）。
    关键路径：是从开始点到完成点的最长路径的长度。路径的长度是边上活动耗费的时间。如上图所示，1 到2 到 5到7到9是关键路径（关键路径不止一条，请输出字典序最小的），权值的和为18。

Input

    这里有多组数据，保证不超过10组，保证只有一个源点和汇点。输入一个顶点数n(2<=n<=10000),边数m(1<=m <=50000),接下来m行，输入起点sv，终点ev,权值w（1<=sv,ev<=n,sv != ev,1<=w <=20)。数据保证图连通。

Output

    关键路径的权值和，并且从源点输出关键路径上的路径（如果有多条，请输出字典序最小的）。

Sample

Input 

9 11
1 2 6
1 3 4
1 4 5
2 5 1
3 5 1
4 6 2
5 7 9
5 8 7
6 8 4
8 9 4
7 9 2

Output 

18
1 2
2 5
5 7
7 9

注意本题要求如果有多条路径，则输入字典序小的，所以不要忘记再更新路径，权值数组时不要忘记这个条件。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXVEX 50001

typedef struct vertex
{
    int pre;
    int rear;
    int weight;
    int out_degree;
    int in_degree;
}Vertex;

Vertex vex[MAXVEX];

void initvex(int n)
{
    for(int i=1;i<=n;i++){
        vex[i].pre = 0;
        vex[i].rear = 0;
        vex[i].weight = 0;
        vex[i].in_degree = 0;
        vex[i].out_degree = 0;
    }
}

void AOE(int n,int m,int pos)
{
    int temp;
    int path[MAXVEX],cost[MAXVEX];
    memset(path,0,sizeof(path));
    memset(cost,0,sizeof(cost));
    for(int i=2;i<=n;i++){
        temp = 0;
        for(int j=1;j<=m;j++){
            if(cost[vex[j].pre]<cost[vex[j].rear]+vex[j].weight ||
(cost[vex[j].pre]==cost[vex[j].rear]+vex[j].weight && vex[j].rear<path[vex[j].pre])){
                cost[vex[j].pre] = cost[vex[j].rear] + vex[j].weight;
                path[vex[j].pre] = vex[j].rear;
                temp = 1;
             }
        }
        if(!temp){
            break;
        }
    }
    printf("%d\n",cost[pos]);
    while(path[pos]){
        printf("%d %d\n",pos,path[pos]);
        pos = path[pos];
    }
}

int main()
{
    int n,m,a,b,c,pos;
    while (scanf("%d%d",&n,&m)!=EOF){
        initvex(n);
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a,&b,&c);
            vex[i].pre = a;
            vex[i].rear = b;
            vex[i].weight = c;
            vex[b].out_degree++;
            vex[a].in_degree++;
        }
        for(int i=1;i<=n;i++){
            if(vex[i].out_degree==0){
                pos = i;
            }
        }
        AOE(n,m,pos);
    }
    return 0;
}

N - 图结构练习——最短路径

Description

 给定一个带权无向图，求节点1到节点n的最短路径。

Input

 输入包含多组数据，格式如下。

第一行包括两个整数n m，代表节点个数和边的个数。(n<=100)

剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。

Output

 每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在）

Sample

Input 

3 2
1 2 1
1 3 1
1 0

Output 

1
0

Hint

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INF 999999
#define MAXVEX 101

int map[MAXVEX][MAXVEX];

void Dijkstra(int n)
{
    int min,pos;
    int vis[MAXVEX],dist[MAXVEX];
    memset(vis,0,sizeof(vis));
    memset(dist,0,sizeof(dist));
    for(int i=1;i<=n;i++){
        dist[i] = map[1][i];
    }
    vis[1] = 1;
    for(int i=1;i<=n;i++){
        min = INF;
        for(int j=1;j<=n;j++){
            if(!vis[j] && dist[j]<min){
                min = dist[j];
                pos = j;
            }
        }
        vis[pos] = 1;
        for(int j=1;j<=n;j++){
            if(!vis[j] && map[pos][j]<INF && dist[j]>map[pos][j]+dist[pos]){
                dist[j] = map[pos][j]+dist[pos];
            }
        }
    }
    printf("%d\n",dist[n]);
}

int main()
{
    int n,m,a,b,c;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(map,INF,sizeof(map));
        for(int i=1;i<=n;i++){
            map[i][i] = 0;
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c){
                map[a][b] = c;
                map[b][a] = c;
            }
        }
        Dijkstra(n);
    }
    return 0;
}

天行九歌。
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构 图的遍历(实现代码).zip
02-29
图的遍历（深度、广度、各自递归、非递归实现）代码 配套文档可下载
Java遍历树（深度优先+广度优先）
weixin_34296641的博客
08-29 402
在编程生活中，我们总会遇见树性结构，这几天刚好需要对树形结构操作，就记录下自己的操作方式以及过程。现在假设有一颗这样树，（是不是二叉树都没关系，原理都是一样的）   1、深度优先 英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。对于上面的例子来说深度优先遍历的结果就是：A,B,D,E,I,C,F...
图的遍历（数据结构作业）
qq_70137750的博客
05-30 254
定义 从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历（Traversing Graph）。 深度优先遍历 深度优先遍历（Depth_First_Search）,也有称深度优先搜索，简称DFS。 为了理解深度优先遍历，用一个小游戏来说明。 假设你要完成一个任务，要求在如图1-1中的左图中这样的一个迷宫中，从顶点A开始要走遍所有的图顶点并做上标记，注意不是简单地看着这样的平面图走哦。而是如同现实般地只有高墙和通道的迷宫中去完成任务。 很显然是需要策略的，现在使.
数据结构《遍历问题》
吃葡萄不吐葡萄皮
08-04 978
描述 已知二叉树的中序和先序遍历可以唯一确定后序遍历、已知中序和后序遍历可以唯一确定先序遍历，但已知先序和后序，却不一定能唯一确定中序遍历。现要求根据输入的中序遍历结果及某一种遍历，要求输出另一种遍历。 输入 输入包括若干个测试用例，第一行为一个自然数n，表示用例个数，接下来4n行，即每个用例占4行，其中第一行表示第一种遍历方式，第二行为第一种遍历结果，第三行为第二种遍历方式
【数据结构】Leetcode——遍历树 经典题
Bryce-HJ
09-25 910
深度优先遍历 前序遍历（递归法，迭代法） 中序遍历（递归法，迭代法） 后序遍历（递归法，迭代法） 广度优先遍历 层次遍历（迭代法） 「这里前中后，其实指的就是中间节点的遍历顺序」，只要大家记住 前中后序指的就是中间节点的位置就可以了。 看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式 前序遍历：中左右 中序遍历：左中右 后序遍历：左右中 前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。 而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出
sdut-sourcesdb
03-22
雨果基金会主题 雨果使用基础6的准系统主题。 安装 按照Hugo Docs网站上的说明下载并安装当前的Hugo二进制文件。跑： $ hugo new site example 然后在您的主题目录中运行 ...使用主题/示例config.toml中的config.toml...
java代码-求最大公约数和最小公倍数
07-15
java代码-求最大公约数和最小公倍数
Sdut-Ver5.2.0
10-26
sdut客sdut客户端
Java面向对象项目-滴滴打车租车系统
08-28
一、项目背景 编写一个控制台程序，要求实现如下功能： 1.展示所有可租车辆 2.选择车型，租车量 3.显示租车清单，包括：总载货量，总载客量，总金额等；
Java面向对象试题-IT公司
06-06
Java面向对象试题-IT公司
数据结构之图的遍历
顾小豆的博客
02-28 4997
图的遍历定义：从图中的某一顶点出发，沿着一些边访遍图中所有的顶点，使得每个顶点仅被访问一次。图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。然而，图的遍历要比树的遍历复杂的多。因为图的任一顶点都可能和其余的顶点相邻接。所以在访问了某个顶点后，可能沿着某条路径搜索之后，又回到该顶点上。为了避免同一个顶点被访问多次，在遍历图的过程中，必须记下每个已访问过的顶点。为此，我们可以设一个...
数据结构——图的遍历
Benson的博客
02-02 620
图的遍历      树常见的遍历方式有先序、中序、后序以及层次遍历，同样，图也有常见的两种遍历方式，分别是深度优先搜索(DFS)和广度优先搜索(BFS)。见名知意，深搜的策略就是从一个节点开始，访问到一个节点就标记一下，向第一个邻接节点方向搜，如果第一个邻接节点已经被标记访问过了，就向每二个邻接节点方向搜等等，再后再向第一个邻接节点的第一个邻接节点搜，这样递归搜索，直到当前访问的节点的所有邻接节
BUAA_数据结构_7TH_1.图遍历（图-基本题）
weixin_45568867的博客
05-21 782
BUAA_数据结构_7TH_1.图遍历（图-基本题） 第七次作业链接 独立路径计算[施工中] 最少布线（图）[施工中] 北京地铁乘坐线路查询[施工中] 题目描述： 给定一个无向图和一个图顶点，编程输出该图删除给定顶点前后按深度优先遍历及广度优先遍历方式遍历的图顶点序列。 给定的无向图和图顶点满足以下要求： 1、无向图的顶点个数n大于等于3，小于等于100，输入时顶点编号用整数0～n-1表示； 2、无向图在删除给定顶点前后都是连通的； 3、无论何种遍历，都是从编号为0的顶点开始遍历，访问相邻顶点时按照编
[蓝桥杯][2013年第四届真题]危险系数-dfs+图的遍历
m0_51955470的博客
03-20 207
题目描述 问题描述 抗日战争时期，冀中平原的地道战曾发挥重要作用。 地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。 我们来定义一个危险系数DF(x,y)： 对于两个站点x和y (x != y), 如果能找到一个站点z，当z被敌人破坏后，x和y不连通，那么我们称z为关于x,y的关键点。相应的，对于任意一对站点x和y，危险系数DF(x,y)就表示为这两点之间的关键点个数。 本题的任务是：已知网络结构，求两站点之间的危险系数。 输入 输入数
数据结构-图的遍历
06-24 2643
判断题 1.图的深度优先遍历非递归算法通常采用队列实现，广度优先遍历非递归算法通常采用堆栈实现。 T F 深度优先是堆栈，广度优先是队列。 2.如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G中一定有回路。 T F 3.如果无向图G必须进行两次广度优先搜索才能访问其...
数据结构---第六章图---图的遍历---应用题
programmer9的博客
08-14 591
数据结构---第六章图---图的遍历---应用题
【PAT数据结构与算法题目集】列出连通集（图的遍历）
hh66__66hh的博客
11-05 641
【PAT数据结构与算法题目集】列出连通集（图的遍历） 题目 给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 输入格式: 输入第1行给出2个整数N(0&amp;lt;N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。 输出...
数据结构OJ作业——图的遍历
nNbS
04-30 903
题目传送门：http://poj.org/problem?id=2386两种姿势可选，一个是比较常规的图的遍历，求连通分量的个数就可以了。第二个是使用并查集，并查集其实本来就是解决连通性的一个很好的工具。dfs:#include <iostream> #include <cstdio> #include <algorithm> #include <cstring> using namespace s
数据结构与算法——图的两道习题(创建，求度，遍历)
Hhhhh
12-22 509
数据结构-图的两道上机题 不好或者多余的地方大佬请多指教 有向图的创建，求度和遍历： 题目和要求： 从键盘接收有向图的顶点集，弧集，创建有向图，并完成下列任务： (1)计算结点的出度、入度以及度; (2) 从第一个顶点出发，求一个深度优先遍历序列; (3) 从第一个顶点顶点出发，求一个广度优先遍历序列。 注意：以用户输入各个顶点的顺序为顶点的序号。 在深度和广度优先遍历中，优先选择序号小的顶点。 ...
sdut-list-map--购物车
最新发布
03-16
sdut-list-map--购物车是一个购物车列表和地图的应用程序。它可以让用户在购物时方便地查看他们的购物车列表和附近的商店位置。用户可以在购物车列表中添加或删除商品，并在地图上查看商店的位置和距离。这个应用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天行九歌。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值