【图论基础】

最新推荐文章于 2024-10-12 22:56:36 发布

你想太多了！

最新推荐文章于 2024-10-12 22:56:36 发布

阅读量320

点赞数 1

文章标签：图论深度优先算法

本文链接：https://blog.csdn.net/qq_71829924/article/details/128519695

版权

使用邻接表实现的深度优先搜索（DFS）和广度优先搜索（BFS）

【深基18.例3】查找文献

题目描述

小K 喜欢翻看洛谷博客获取知识。每篇文章可能会有若干个（也有可能没有）参考文献的链接指向别的博客文章。小K 求知欲旺盛，如果他看了某篇文章，那么他一定会去看这篇文章的参考文献（如果他之前已经看过这篇参考文献的话就不用再看它了）。

假设洛谷博客里面一共有 $n(n\le10^5)$ 篇文章（编号为 1 到 $n$ ）以及 $m(m\le10^6)$ 条参考文献引用关系。目前小 K 已经打开了编号为 1 的一篇文章，请帮助小 K 设计一种方法，使小 K 可以不重复、不遗漏的看完所有他能看到的文章。

这边是已经整理好的参考文献关系图，其中，文献 X → Y 表示文章 X 有参考文献 Y。不保证编号为 1 的文章没有被其他文章引用。

请对这个图分别进行 DFS 和 BFS，并输出遍历结果。如果有很多篇文章可以参阅，请先看编号较小的那篇(因此你可能需要先排序)。

输入格式

共 $m + 1$ 行，第 1 行为 2 个数， $n$ 和 $m$ ，分别表示一共有 $n(n\le10^5)$ 篇文章（编号为 1 到 $n$ ）以及 $m(m\le10^6)$ 条参考文献引用关系。

接下来 $m$ 行，每行有两个整数 $X, Y$ 表示文章 X 有参考文献 Y。

输出格式

共 2 行。
第一行为 DFS 遍历结果，第二行为 BFS 遍历结果。

样例 #1

样例输入 #1

样例输出 #1

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

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

// 存储边的结构体
struct edge
{
    int u; // 边的起点
    int v; // 边的终点
};

const int N = 1e6 + 1; // 定义常量 N

vector<edge> s;
bool vis1[N] = {0}, vis2[N] = {0};
// 定义邻接表
vector<int> e[N]; // e[i] 存储以 i 为起点的边的编

void dfs(int x = 1)
{
    vis1[x] = 1;      // 标记当前节点已被访问
    cout << x << " "; // 输出节点的编号
    for (int i = 0; i < e[x].size(); i++)
    {
        int p = s[e[x][i]].v; // p 为 x 的一个邻接节点
        if (!vis1[p])         // 如果 p 还未被访问
        {
            dfs(p); // 递归调用 dfs 函数，继续搜索
        }
    }
}

void bfs(int x = 1)
{
    queue<int> q;     // 定义一个队列
    q.push(x);        // 将起点 x 压入队列
    cout << x << " "; // 输出节点的编号
    vis2[x] = 1;      // 标记当前节点已被访问
    while (!q.empty())
    {
        int f = q.front();                    // 取出队列首元素
        for (int i = 0; i < e[f].size(); i++) // 遍历 f 的邻接节点
        {
            int p = s[e[f][i]].v; // p 为 f 的一个邻接节点
            if (!vis2[p])         // 如果 p 还未被访问
            {
                q.push(p);        // 将 p 压入队列
                cout << p << " "; // 输出节点的编号
                vis2[p] = 1;      // 标记当前节点已被访问
            }
        }
        q.pop(); // 弹出队列首元素
    }
}

int main()
{
    int n, m;
    cin >> n >> m; // 读入结点数和边数

    // 读入边的信息
    for (int i = 0; i < m; i++)
    {
        int u, v;
        cin >> u >> v;
        s.push_back((edge){u, v}); // 将边的信息添加到s容器中
    }
    // 按照终点的编号从小到大的顺序排序
    sort(s.begin(), s.end(), [](edge x, edge y)
         { return (x.v == y.v && x.u < y.u) || (x.v < y.v); });

    // 建立邻接表
    for (int i = 0; i < m; i++)
    {
        e[s[i].u].push_back(i); // 将边的编号加入邻接表
    }

    dfs();        // 从节点 1 开始深度优先搜索
    cout << endl; // 换行
    bfs();        // 从节点 1 开始广度优先搜索
}

Floyd 算法是一种动态规划算法，用于计算有权图中所有点对的最短路径。它的基本思想是枚举中间结点，如果通过中间结点可以使距离更短，就更新距离。

【模板】floyd

题目背景

模板题，无背景

题目描述

给出n个点，m条边的无向图，求每个点到其他点的距离之和%998244354的值

输入格式

第一行两个数n，m含义如上
从第二行开始，共m行，每行三个数x，y，l，代表从x到y点的长度为l

输出格式

n行，每行一个数，第i行代表点i到其他点的距离之和

样例 #1

样例输入 #1

2 1
1 2 4

样例输出 #1

4
4

样例 #2

样例输入 #2

样例输出 #2

提示

模板题，保证图联通
n<=500
m<=10000
1<=x,y<=n
l<=1e9

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

// g[i][j] 表示从 i 到 j 的最短路径长度，sum[i] 表示从第 i 个结点出发到其他结点的最短路径长度之和
long long g[501][501], sum[501];

int main()
{
    int n, m;
    cin >> n >> m; // 读入结点数和边数
    long long x, y, l;
    for (int i = 1; i <= n; ++i) // 初始化邻接矩阵
    {
        for (int j = 1; j <= n; ++j)
        {
            g[i][j] = 1e10; // 将所有距离初始化为无穷大
            g[i][i] = 0;    // 将节点到自身的距离初始化为 0
        }
    }
    for (int i = 1; i <= m; ++i) // 读入边的信息
    {
        cin >> x >> y >> l;
        g[x][y] = min(l, g[x][y]); // 将边的距离与之前的距离取较小值
        g[y][x] = min(l, g[y][x]); // Floyd 算法中有向边和无向边的处理方式是一样的
    }
    for (int i = 1; i <= n; ++i) // 枚举中间结点
    {
        for (int j = 1; j <= n; ++j) // 枚举起点和终点
        {
            if (j == i)
                continue;                // 如果起点和终点是同一个点，则跳过
            for (int h = 1; h <= n; ++h) // 枚举终点
            {
                if (h == i || h == j)
                    continue;                              // 如果终点是起点或中间点，则跳过
                g[j][h] = min(g[j][h], g[j][i] + g[i][h]); // 如果通过中间点能使距离更短，则更新距离
            }
        }
    }
    for (int i = 1; i <= n; ++i) // 遍历所有结点
    {
        for (int j = 1; j <= n; ++j) // 遍历从当前结点出发的所有边
        {
            sum[i] = (sum[i] + g[i][j]) % 998244354; // 统计距离和
        }
        cout << sum[i] << endl; // 输出距离和
    }
}

Dijkstra 算法是一种贪心算法，用于计算有权图中单源最短路径。它的基本思想是每一次选择距离源点最近的未标记顶点并标记。

【模板】单源最短路径（标准版）

题目背景

2018 年 7 月 19 日，某位同学在 NOI Day 1 T1 归程一题里非常熟练地使用了一个广为人知的算法求最短路。

然后呢？

$\rightarrow 60$ ；

$\text{Ag} \rightarrow \text{Cu}$ ；

最终，他因此没能与理想的大学达成契约。

小 F 衷心祝愿大家不再重蹈覆辙。

题目描述

给定一个 $n$ 个点， $m$ 条有向边的带非负权图，请你计算从 $s$ 出发，到每个点的距离。

数据保证你能从 $s$ 出发到任意点。

输入格式

第一行为三个正整数 $n, m, s$ 。
第二行起 $m$ 行，每行三个非负整数 $u_i, v_i, w_i$ ，表示从 $u_i$ 到 $v_i$ 有一条权值为 $w_i$ 的有向边。

输出格式

输出一行 $n$ 个空格分隔的非负整数，表示 $s$ 到每个点的距离。

样例 #1

样例输入 #1

样例输出 #1

0 2 4 3

提示

样例解释请参考数据随机的模板题。

$\leq n \leq 10^5$ ；

$\leq m \leq 2\times 10^5$ ；

$s = 1$ ；

$\leq u_i, v_i\leq n$ ；

$\leq w_i \leq 10 ^ 9$ ,

$\leq \sum w_i \leq 10 ^ 9$ 。

本题数据可能会持续更新，但不会重测，望周知。

2018.09.04 数据更新 from @zzq

#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e6 + 10, MaxM = 5e6 + 10;
// 定义边结构体，其中 to 表示连接的目标节点，dis 表示边权，next 表示下一条边的编号
struct edge
{
  int to, dis, next;
} path[MaxM]; // 存储边的数组

// 邻接表存储图中的边，head[i] 表示以 i 为起点的边的编号
int head[MaxN], dis[MaxN], cnt;

// sets[i] 表示节点 i 是否已经在最短路径集合中，n、m 分别表示节点数和边数，s 表示源点
bool sets[MaxN];
int n, m, s;

// 添加一条从 u 到 v，边权为 d 的边
void add_edge(int u, int v, int d)
{
  cnt++;
  path[cnt].dis = d;        // 边权为 d
  path[cnt].to = v;         // 连接到节点 v
  path[cnt].next = head[u]; // 更新以 u 为起点的边的编号的next
  head[u] = cnt;            // 更新以 u 为起点的边的编号
}

// 定义优先队列的节点，dis 表示到源点的距离，pos 表示节点编号
struct node
{
  int dis;
  int pos;
  bool operator<(const node &x) const
  {
    return x.dis < dis; // 重载小于号，使得优先队列中的元素按 dis 从大到小排序
  }
};
priority_queue<node> q; // 定义优先队列

// Dijkstra 算法主函数
void dijkstra()
{
  dis[s] = 0;         // 初始化源点到自身的距离为 0
  q.push(node{0, s}); // 将源点加入优先队列
  while (!q.empty())  // 当优先队列不为空时
  {
    node tmp = q.top(); // 取出距离最小的节点
    q.pop();
    int x = tmp.pos, d = tmp.dis; // x 表示节点编号，d 表示到源点的距离
    if (sets[x])
      continue;  // 如果节点已经在最短路径集合中，则跳过
    sets[x] = 1; // 将节点加入最短路径集合
    for (int i = head[x]; i; i = path[i].next)
    {                     // 遍历以 x 为起点的边
      int y = path[i].to; // y 表示边的终点
      if (dis[y] > dis[x] + path[i].dis)
      {                                // 如果从 x 到 y 的距离小于之前的距离
        dis[y] = dis[x] + path[i].dis; // 更新 y 到源点的距离
        if (!sets[y])
        {                          // 如果 y 还没有在最短路径集合中
          q.push(node{dis[y], y}); // 将 y 加入优先队列
        }
      }
    }
  }
}

int main()
{
  cin >> n >> m >> s;
  memset(dis, 0x3f3f, sizeof(dis)); // 将 dis 数组初始化为无穷大
  int u, v, d;                      // 读入边的信息
  for (int i = 0; i < m; ++i)
  {
    cin >> u >> v >> d;
    add_edge(u, v, d); // 添加一条从 u 到 v，边权为 d 的边
  }
  dijkstra(); // 运行 Dijkstra 算法
  for (int i = 1; i <= n; ++i)
  {
    cout << dis[i] << " "; // 输出第 i 个节点到源点的最短路径长度
  }
}