图的概念、存储与遍历

SMall_X_

已于 2024-05-10 23:19:22 修改

阅读量577

点赞数 24

文章标签：图论

于 2024-05-10 23:18:48 首次发布

本文链接：https://blog.youkuaiyun.com/shimingxin1007/article/details/138685841

版权

存储

邻接矩阵

邻接矩阵适用于稠密图，我们可以定义一个二维数组 $g [] []$ ，对于 $u$ 、 $v$ 两个结点，我们可以用 $g [u] [v]$ 来表示这两个点有一条边，如果是带权图，则可以记录这条边的权值，构造的空间复杂度是 $O(n^2)$ ，但查询两个结点的时间复杂度只有 $O (1)$ 。

$\texttt{code}$

int g[MAXN][MAXN];
......
for(int i=1;i<=m;i++){
	int u,v;
    cin>>u>>v;
	g[u][v]=1;//如果是无向图，这里应该是 g[u][v]=g[v][u]=1
}

邻接表

邻接表主要适用于稀疏图，我们定义 $n$ 个向量，用于存储结点 $u$ 可以直接到达的所有结点，如果是带权图，可以开一个结构体 node，含有二维信息 to 和 w，分别表示到达的顶点和这两个点之间的边权，当然也可以用 pair 来记录这两个值，空间复杂度 $O (m)$ ，但是判断两个结点是否有连边，需要遍历整个 vector 查询，最坏时间复杂度 $O (n)$ 。

$\texttt{code}$

vector<int> g[MAXN];
......
for(int i=1;i<=m;i++){
    int u,v;
    cin>>u>>v;
    g[u].push_back(v);
   	g[v].push_back(u);//无向图
}
//1


struct node{
    int to,w;
}
vector<node> g[MAXN];
......
for(int i=1;i<=m;i++){
    int u,v,w;
    cin>>u>>v>>w;
    g[u].push_back((node){v,w});
   	g[v].push_back((node){u,w});
}
//2


vector<pair<int,int>> g[MAXN];
......
for(int i=1;i<=m;i++){
    int u,v,w;
    cin>>u>>v>>w;
    g[u].push_back(make_pair(v,w));
   	g[v].push_back(make_pair(u,w));
}
//3

存边

除了以上两种存点的方式，还可以用结构体存储一条边，结构体中的成员变量 fr、to、w，分别表示这条边所连接的两个结点和这条边的边权，空间复杂度 $O (m)$ 。

struct Edge{
    int fr,to,w;
}edges[MAXN];

遍历

图的 bfs 遍历：

$\texttt{code}$

vector<int> g[MAXN];
void bfs(int s){
	queue<int> q;
	q.push(s);
	vis[s]=1;
	while(!q.empty()){
		int now=q.front();
		cout<<now<<" ";
		q.pop();
		for(auto x:g[now]){
			if(vis[x]==0){
				vis[x]=1;
				q.push(x);
			}
		}
	}
}

图的 dfs 遍历：

$\texttt{code}$

vector<int> g[MAXN];
void dfs(int now){
	cout<<now<<" ";
	vis[now]=1;
	for(auto x:g[now]){
		if(vis[x]==0){
			dfs(x);
		}
	}
}

以上两种写法的时间复杂度是 $O (n + m)$ 。

拓扑排序

对于一个有向无环图，有一个遍历顺序，是等一个结点的所有前驱结点都遍历完了，才遍历这个结点。这种顺序就叫做拓扑序。

对于下面这张图，它的拓扑序可以是 1 2 3 4 5，而 1 2 4 3 5 则不是，因为 $4$ 的前驱还有 $3$ 没有遍历，必须先遍历 $3$ 才能遍历 $4$ 。

$\texttt{code}$

int in[MAXN],res[MAXN];
vector<int> g[MAXN];
int num;
int topo(){
    for(int i=1;i<=n;i++){
        for(auto x:g[i]){
        	in[x]++;
        }
    }
    queue<int> q;
    for(int i=1;i<=n;i++){
        if(in[i]==0){ 
            q.push(i);
        }
    }
    while(!q.empty()){
        int k=q.front();
        q.pop();
        res[++num]=k;
        for(auto x:g[k]){
        	in[x]--;
        	if(in[x]==0){
                q.push(x);
            }
        }
    }
    if(num!=n){
        return false;
    }else{ 
        return true;
    }
}

时间复杂度 $O (n + m)$ 。

欧拉路径问题

给你一个图，请你选择一个起点出发，经过所有的边，要求每条边只能经过一次，问能否达成目标，也称一笔画问题。

欧拉定理：如果一张连通图，只有 $0$ 个或者 $2$ 个结点，他的度为奇数，那么这张图可以一笔画。

证明：我们选择一个度数为奇数的顶点出发，走向一个度数为偶数的顶点，那么这个图变成了一个仍然满足上述性质但是结构更简单的图了。所以我们可以归纳证明上述定理。

对于这道题，我们可以使用 Hierholzer算法，它的思路是，对于欧拉回路，我相当于是将图拆成若干个环。所以我每次找图的正好一个环，如果没法找了，我就回溯地把这个环给存起来，存到栈中。

$\texttt{code}$

vector<pair<int,int>> g[MAXN];
stack<int> s;
int vis[maxm];//对边标记
void dfs(int now){
    for(auto x:g[now]){
        if(vis[x.second]==0){
        	vis[x.second]=1;
        	dfs(x.first);
        }
    }
    s.push(now);
}