图的存储

1|0约定

在本文中，用 $n$ 代指图的点数，用 $m$ 代指图的边数，用 $d^{+}(u)$ 代指点 $u$ 的出度，即以 $u$ 为出发点的边数。

2|0直接存边

1|0方法

使用一个数组来存边，数组中的每个元素都包含一条边的起点与终点（带边权的图还包含边权）。（或者使用多个数组分别存起点，终点和边权。）

#include <iostream>
#include <vector>

using namespace std;

struct Edge {
  int u, v;
};

int n, m;
vector<Edge> e;
vector<bool> vis;

bool find_edge(int u, int v) {
  for (int i = 1; i <= m; ++i) {
    if (e[i].u == u && e[i].v == v) {
      return true;
    }
  }
  return false;
}

void dfs(int u) {
  if (vis[u]) return;
  vis[u] = true;
  for (int i = 1; i <= m; ++i) {
    if (e[i].u == u) {
      	dfs(e[i].v);
    }
  }
}

int main() {
      cin >> n >> m;
      vis.resize(n + 1, false);
      e.resize(m + 1);
      for (int i = 1; i <= m; ++i) cin >> e[i].u >> e[i].v;
      return 0;
}

1|0复杂度

查询是否存在某条边：$O(m)$。

遍历一个点的所有出边：$O(m)$。

遍历整张图：$O(nm)$。

空间复杂度：$O(m)$。

1|0应用

由于直接存边的遍历效率低下，一般不用于遍历图。

在 Kruskal 算法 中，由于需要将边按边权排序，需要直接存边。

在有的题目中，需要多次建图（如建一遍原图，建一遍反图），此时既可以使用多个其它数据结构来同时存储多张图，也可以将边直接存下来，需要重新建图时利用直接存下的边来建图。

3|0邻接矩阵

1|0方法

使用一个二维数组 adj 来存边，其中 adj[u][v] 为 1 表示存在 到 的边，为 0 表示不存在。如果是带边权的图，可以在 adj[u][v] 中存储 $u$ 到 $v$ 的边的边权。

#include <iostream>
#include <vector>

using namespace std;

int n, m;
vector<bool> vis;
vector<vector<bool> > adj;

bool find_edge(int u, int v) { return adj[u][v]; }

void dfs(int u) {
  if (vis[u]) return;
  vis[u] = true;
  for (int v = 1; v <= n; ++v) {
    if (adj[u][v]) {
      dfs(v);
    }
  }
}

int main() {
  cin >> n >> m;

  vis.resize(n + 1, false);
  adj.resize(n + 1, vector<bool>(n + 1, false));

  for (int i = 1; i <= m; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u][v] = true;
  }

  return 0;
}

1|0复杂度

查询是否存在某条边：$O(1)$。

遍历一个点的所有出边：$O(n)$。

遍历整张图：$O(n^2)$。

空间复杂度：$O(n^2)$。

1|0应用

邻接矩阵只适用于没有重边（或重边可以忽略）的情况。

其最显著的优点是可以 $O(1)$ 查询一条边是否存在。

由于邻接矩阵在稀疏图上效率很低（尤其是在点数较多的图上，空间无法承受），所以一般只会在稠密图上使用邻接矩阵。

4|0邻接表

1|0方法

使用一个支持动态增加元素的数据结构构成的数组，如 vector<int> adj[n + 1] 来存边，其中 adj[u] 存储的是点 的所有出边的相关信息（终点、边权等)。

#include <iostream>
#include <vector>

using namespace std;

int n, m;
vector<bool> vis;
vector<vector<int> > adj;

bool find_edge(int u, int v) {
  for (int i = 0; i < adj[u].size(); ++i) {
    if (adj[u][i] == v) {
      return true;
    }
  }
  return false;
}

void dfs(int u) {
  if (vis[u]) return;
  vis[u] = true;
  for (int i = 0; i < adj[u].size(); ++i) dfs(adj[u][i]);
}

int main() {
  cin >> n >> m;

  vis.resize(n + 1, false);
  adj.resize(n + 1);

  for (int i = 1; i <= m; ++i) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
  }

  return 0;
}

1|0复杂度

查询是否存在 $u$ 到 $v$ 的边 $O(d^{+}(u))$（如果事先进行了排序就可以使用 二分查找 做到 $O(\log (d^{+}(u)))$。

遍历点 $u$ 的所有出边：$O(d^{+}(u))$。

遍历整张图：$O(n+m)$。

空间复杂度：$O(m)$。

1|0应用

存各种图都很适合，除非有特殊需求（如需要快速查询一条边是否存在，且点数较少，可以使用邻接矩阵）。

尤其适用于需要对一个点的所有出边进行排序的场合。

并且相较于链式前向星，它能排序，而且还不需要实现算好有多少条边。

5|0链式前向星

1|0方法

本质上是用链表实现的邻接表。

图论复习之链式前向星存图

• 数组实现

#include <bits/stdc++.h>
using namespace std;

#define N 10005

struct edge {
    int next, to, w;
} e[N];

int head[N];
int cnt = 0;

void add_edge(int u, int v, int w) {
    cnt ++;
    e[cnt].to = v, e[cnt].w = w;
    e[cnt].next = head[u], head[u] = cnt;
}

int n, m;
int u, v, w;

int main() {
    memset(head, 0, sizeof(int));
    scanf("%d%d", &n, &m)
    read(n), read(m);
    for (int i = 1; i <= m; i ++) {
        scanf("%d%d%d", &u, &v, &w);
        add_edge(u, v, w);
    }
    for (int i = 1; i <= n; i ++)
        if (head[i])
            for (int j = head[i]; j != 0; j = e[j].next)
                printf("%d %d %d\n", i, e[j].to, e[j].c);
        else printf("\n");
    return 0;
}

• vector 实现：

#include <iostream>
#include <vector>

using namespace std;

int n, m;
vector<bool> vis;
vector<int> head, nxt, to;

void add(int u, int v) {
  nxt.push_back(head[u]);
  head[u] = to.size();
  to.push_back(v);
}

bool find_edge(int u, int v) {
  for (int i = head[u]; ~i; i = nxt[i]) {  // ~i 表示 i != -1
    if (to[i] == v) {
      return true;
    }
  }
  return false;
}

void dfs(int u) {
  if (vis[u]) return;
  vis[u] = true;
  for (int i = head[u]; ~i; i = nxt[i]) dfs(to[i]);
}

int main() {
  cin >> n >> m;

  vis.resize(n + 1, false);
  head.resize(n + 1, -1);

  for (int i = 1; i <= m; ++i) {
    int u, v;
    cin >> u >> v;
    add(u, v);
  }

  return 0;
}

1|0复杂度

查询是否存在 $u$ 到 $v$ 的边：$O(d^{+}(u))$。

遍历点 $u$ 的所有出边：$O(d^{+}(u))$。

遍历整张图：$O(n+m)$。

空间复杂度：$O(m)$。

1|0应用

存各种图都很适合，但不能快速查询一条边是否存在，也不能方便地对一个点的出边进行排序。

优点是边是带编号的，有时会非常有用，而且如果 cnt 的初始值为奇数，存双向边时 i ^ 1 即是 i 的反边（常用于 网络流）。

__EOF__

本文作者：Kdlyh
本文链接：https://www.cnblogs.com/kdlyh/p/17868518.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！