邻接矩阵-有向图-拓扑序列

最新推荐文章于 2024-10-31 16:16:13 发布

enoien

最新推荐文章于 2024-10-31 16:16:13 发布

阅读量941

点赞数 7

文章标签：算法数据结构

本文链接：https://blog.csdn.net/2401_85642272/article/details/142629470

版权

若采用邻接矩阵有向图，矩阵中主对角线以下的元素均为零，则关于该图拓扑序列的结论是（ ) 。
A:满二叉树中
B:存在，且唯一
D:存在，可能不唯一
D:无法确定是否存在

有向无环图

有向无环图(Directed acyclic graph, DAG)，字面意思，就是一个没有环的有向图。
比如下图就是一个 DAG：

而下图就不是一个 DAG，因为它存在环 1 − 3 − 5 − 1 ：

发现，只有父亲指向儿子的边的树是一个 DAG。

DAG 作为特殊的有向图，在各方面都有很重要的作用。
比如，凡是可以进行 dp（动态规划）的数据，其承接关系一定是一个 DAG。

DAG 有一个非常重要的性质：一个 DAG 中，必然存在至少一个顶点的入度为 0，至少一个顶点的出度为 0。
下面的拓扑排序便利用了这个性质。

拓扑排序

拓扑排序(topological-sort, toposort, topsort)，是对一个 DAG G，将G中所有所有顶点排成一个线性序列，使得图中任意一对顶点 u , v ，若边 u → v ∈ E ( G ) ，则 u 在线性序列中出现在 v之前。所以说，它不是对数据的一种排序算法。

下面我们需要一个队列q。
我们首先找到所有入度为0 的节点，依次加入q。比如上述例子中此时 q = { 2 } 。
然后进行循环的操作：

取出队首节点x，将所有以它为起点的边删去，也就是对于所有存在的边 x → i ，进行 din[i]--；
对于每个进行 din[i]-- 的 i,看它操作之后的 din i 是否为 0，是则加入队列，然后重复上面的操作。

可以看出来，操作其实就是对每一条有向边 u → v u\rightarrow vu→v，保证 u uu 在前 v vv 在后即可。
最后我们排序出来的一种可能的方案：
#include<bits/stdc++.h>
using namespace std;

vector<int>g[105];
queue<int>q;
int n,din[105];

void toposort()
{
	for(int i=1;i<=n;i++)
	{
		if(din[i]) continue;
		q.push(i);
	}
	while(!q.empty())
	{
		int x=q.front();
		q.pop();
		cout<<x<<' ';
		for(auto i:g[x])
		{
			if(!--din[i]) q.push(i);
		}
	}
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		int x;
		cin>>x;
		while(x)
		{
			din[x]++;
			g[i].push_back(x);
			cin>>x;
		}
	}
	toposort();
 	return 0;
}

邻接矩阵

1.有向图和无向图的邻接矩阵

由于无向图和无向图的边都是没有权值的，所以我们用1表示某两顶点之间有边存在，用0表示这两边是没有边存在的。

首先，G2,有4个顶点，所以用一个（n*n）即5*5的数组来存这个图，也就是说，我们要建一个这么大的邻接矩阵；

行分别表示v1 v2 v3 v4;

列也是v1 v2 v3 v4;

我们需要了解的一点就是！v(i,j)表示vi到vj之间是否有边；

先看v1这个顶点，他和v2 v4相连; 看第一行（也就是v1这一行），找到v2和v4下面都写上1；
再看v2这个顶点，他和v1 v3 v5相连; 看第二行（也就是v2这一行），找到v1和v3、v5下面都写上1；
再看v3这个顶点，他和v2 v4 v5相连; 我们看第三行（也就是v3这一行），找到v2和v4、v5下面都写上1；
看v4这个顶点，他和v1 v3相连; 看第四行（也就是v4这一行），找到v1和v3下面都写上1；
看v5这个顶点，他和v2 v3相连; 看第五行（也就是v5这一行），找到v2和v3下面都写上1；
其他没有边的写为0；

G1是一个有向图，也就是同理，只不过有向图他两点之间是用箭头链接，这样我们只要看，谁指向谁，就说明这两个之间是联通的。

v<i,j>就表示i到j之间是否为通的。

这里的G1，4个顶点

#include<iostraem>
#include<malloc>
#include<string>
#include<cstring> 
#define MVNum 100;
typedef VerTexType char;
using namespace std;
//邻接矩阵（数组/顺序存储）
typedef struct {
	VerTexType vexs[MVNum];//顶点表
	Arctype arcs[MVNum][MVNum];//邻接表,,记得初始化为0奥，我这里没有写了
	int vexnum,arcnum;//分别表示顶点数和边的数量
}AMGraph;
 
int Locate(AmGraph G,VerTexType u){
	for(int i=0;i<G.vexnum;i++)
	{
		if(G.vexs[i]==u)
		return i;
	}
	return -1;
}
Status 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.arcnum;i++)
	 for(int j=0;j<G.arcnum;j++)
	 {
	 	G.arcs[i][j]=INT_MAX;
	 }
	VerTexType v1,v2;
	int i,j,w;
	for(int k=0;k<G.arcnum;k++)
	{
		cin>>v1>>v2;
		i=Locate(G,v1);
		j=Locate(G,v2);
		G.arcs[i][j]=1;
		G.arcs[i][j]=G.arcs[j][i];
	}
	return 1;
}

2.网的邻接矩阵

接下来是网的邻接矩阵了，这里注意就是，链接两点的边如果有权值我们就把他叫做网，这时候，邻接矩阵中对应得v[i][j]就不是表示存不存在边了，而是写他这一条边的权值：

方法同上，只不过这里把没有边改成了无穷大；方便我们做后面的算法；

#include<iostraem>
#include<malloc>
#include<string>
#include<cstring> 
#define MVNum 100;
typedef VerTexType char;
using namespace std;
//邻接矩阵（数组/顺序存储）
typedef struct {
	VerTexType vexs[MVNum];//顶点表
	Arctype arcs[MVNum][MVNum];//邻接表
	int vexnum,arcnum;//分别表示顶点数和边的数量
}AMGraph;
 
int Locate(AmGraph G,VerTexType u){
	for(int i=0;i<G.vexnum;i++)
	{
		if(G.vexs[i]==u)
		return i;
	}
	return -1;
}
Status 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.arcnum;i++)
	 for(int j=0;j<G.arcnum;j++)
	 {
	 	G.arcs[i][j]=INT_MAX;
	 }
	VerTexType v1,v2;
	int i,j,w;
	for(int k=0;k<G.arcnum;k++)
	{
		cin>>v1>>v2>>w;
		i=Locate(G,v1);
		j=Locate(G,v2);
		G.arcs[i][j]=w;
		G.arcs[i][j]=G.arcs[j][i];
	}
	return 1;
}