【图论基础详解】

最新推荐文章于 2024-09-10 11:26:29 发布

你想太多了！

最新推荐文章于 2024-09-10 11:26:29 发布

阅读量321

点赞数

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

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

版权

本文介绍了图论的基础概念，包括无向图、有向图、连通性、路径、环、稀疏图与稠密图等。重点讲解了在图中寻找特定路径的算法，如深搜和反向建边。同时，给出了实际问题的解题思路，如最少河蟹封锁策略和危险系数计算。文章通过实例展示了如何利用DFS解决图的遍历问题，以及如何优化搜索过程提高效率。

摘要由CSDN通过智能技术生成

[蓝桥杯 2013 国 C] 危险系数

题目背景

抗日战争时期，冀中平原的地道战曾发挥重要作用。

题目描述

地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。

我们来定义一个危险系数 $D F (x, y)$ ：

对于两个站点 $x$ 和 $y(x\neq y),$ 如果能找到一个站点 $z$ ，当 $z$ 被敌人破坏后， $x$ 和 $y$ 不连通，那么我们称 $z$ 为关于 $x, y$ 的关键点。相应的，对于任意一对站点 $x$ 和 $y$ ，危险系数 $D F (x, y)$ 就表示为这两点之间的关键点个数。

本题的任务是：已知网络结构，求两站点之间的危险系数。

输入格式

输入数据第一行包含 $2$ 个整数 $\le n \le 1000)$ ， $\le m \le 2000)$ ，分别代表站点数，通道数。

接下来 $m$ 行，每行两个整数 $\le u,v \le n,u\neq v)$ 代表一条通道。

最后 $1$ 行，两个数 $u, v$ ，代表询问两点之间的危险系数 $D F (u, v)$ 。

输出格式

一个整数，如果询问的两点不连通则输出 $- 1$ 。

样例 #1

样例输入 #1

样例输出 #1

提示

时限 1 秒, 64M。蓝桥杯 2013 年第四届国赛

1.题目大意:

给你 nn 个点，mm 条边。注意：这里是双向边。 再给定起点和终点，求从起点到终点必须经过点的个数。

2.分析：

这道题的 nn 和 mm 都很小，可以用深搜做。

#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
vector<int> G[N];
int st, ed;
bool book[N];
int counts[N];
int total;
void dfs(int now)
{
    if (now == ed) //结束条件，深搜到末尾
    {
        total++; //计算能深搜到末尾的点的个数
        for (int i = 1; i <= n; i++)
        {
            if (book[i])
            {
                counts[i]++; //计算深搜过程中每个点被访问的次数
            }
        }
        return; //结束深搜
    }
    for (int i = 0; i < G[now].size(); i++) //遍历当前点的下一步能到达的所有点
    {
        int to = G[now][i]; //记录当前点下一步能到达的其中一个点
        if (!book[to])      //如果没被访问过，则标记
        {
            book[to] = true;
            dfs(to);          //搜索下一个点
            book[to] = false; //搜完后取消标记
        }
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y); //无向图
        G[y].push_back(x);
    }
    cin >> st >> ed;
    book[st] = true; //第一个点肯定为已经访问过
    dfs(st);
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        if (counts[i] == total)
        //如果某个点在深搜中被访问过的次数等于深搜的次数，即每次搜索必有该点，那么该点为关键点
        {
            ans++;
        }
    }
    ans -= 2; //由于起始点和结束点不被包括在答案内，所以要掐头去尾
    cout << ans;
}

图的遍历

题目描述

给出 $N$ 个点， $M$ 条边的有向图，对于每个点 $v$ ，求 $A (v)$ 表示从点 $v$ 出发，能到达的编号最大的点。

输入格式

第 $1$ 行 $2$ 个整数 $N, M$ ，表示点数和边数。

接下来 $M$ 行，每行 $2$ 个整数 $U_i,V_i$ ，表示边 $U_i,V_i)$ 。点用 $1,2,\dots,N$ 编号。

输出格式

一行 $N$ 个整数 $A(1),A(2),\dots,A(N)$ 。

样例 #1

样例输入 #1

样例输出 #1

4 4 3 4

提示

对于 $60\%$ 的数据， $\leq N,M \leq 10^3$ 。
对于 $100\%$ 的数据， $\leq N,M \leq 10^5$ 。

反向建边 + dfs

按题目来每次考虑每个点可以到达点编号最大的点，不如考虑较大的点可以反向到达哪些点

循环从N到1，则每个点i能访问到的结点的A值都是i

每个点访问一次，这个A值就是最优的，因为之后如果再访问到这个结点那么答案肯定没当前大了

#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
inline int read() //快速读取
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int n, m;
vector<int> G[N];
int counts[N];
void dfs(int now, int max)
{
    if (counts[now]) //如果已经标记过，则结束搜索
        return;
    counts[now] = max;                      //起始点能到达的点都标记为起始点的编号
    for (int i = 0; i < G[now].size(); i++) //遍历从该点下一步能到达的所有点，进一步搜索
    {
        dfs(G[now][i], max);
    }
}
int main()
{
    n = read();
    m = read();
    for (int i = 1; i <= m; i++)
    {
        int x = read(), y = read();
        // G[x].push_back(y);
        G[y].push_back(x); //由于正向搜索比较费时，因此可以考虑逆向搜索
    }
    for (int i = n; i; i--)
    //从最大的编号开始，往小的搜搜，所有被访问过的点对应的最大编号答案即为该点
    {
        dfs(i, i);
    }
    for (int i = 1; i <= n; i++)
    {
        cout << counts[i] << " ";
    }
}

封锁阳光大学

题目描述

曹是一只爱刷街的老曹，暑假期间，他每天都欢快地在阳光大学的校园里刷街。河蟹看到欢快的曹，感到不爽。河蟹决定封锁阳光大学，不让曹刷街。

阳光大学的校园是一张由 $n$ 个点构成的无向图， $n$ 个点之间由 $m$ 条道路连接。每只河蟹可以对一个点进行封锁，当某个点被封锁后，与这个点相连的道路就被封锁了，曹就无法在这些道路上刷街了。非常悲剧的一点是，河蟹是一种不和谐的生物，当两只河蟹封锁了相邻的两个点时，他们会发生冲突。

询问：最少需要多少只河蟹，可以封锁所有道路并且不发生冲突。

输入格式

第一行两个正整数，表示节点数和边数。
接下来 $m$ 行，每行两个整数 $u, v$ ，表示点 $u$ 到点 $v$ 之间有道路相连。

输出格式

仅一行如果河蟹无法封锁所有道路，则输出 Impossible，否则输出一个整数，表示最少需要多少只河蟹。

样例 #1

样例输入 #1

样例输出 #1

Impossible

样例 #2

样例输入 #2

3 2
1 2
2 3

样例输出 #2

提示

【数据规模】
对于 $100\%$ 的数据， $1\le n \le 10^4$ ， $1\le m \le 10^5$ ，保证没有重边。

dfs+染色

因为整张图可能包含多张小图，遍历每一个节点，如果还有没搜过的节点就以当前节点为根开始bfs

bfs过程中如果遇到相邻节点染色相同的情况就跳出，输出impossible即可

染色方案选取较小的一种

#include <bits/stdc++.h>
using namespace std;
inline int read() //快速读取
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}
int m, n;
const int N = 1e5 + 5;
int a[N];
int t[2]; //记录颜色
bool vis[N];
vector<int> G[N];
bool dfs(int u, int color)
{
    vis[u] = true;                        //标记当前点已经访问过
    a[u] = color;                         //涂色
    t[color]++;                           //该种颜色的数量加一
    for (int i = 0; i < G[u].size(); i++) //遍历当前点的下一步能到达的所有点
    {
        int v = G[u][i];            //记录下一个点
        if (vis[v] && a[v] == a[u]) //下一个点访问过而且颜色跟当前颜色相同
            return 0;               //就结束搜索，返回false
        else if (!vis[v])           //没访问过
        {
            bool flag = dfs(v, (color + 1) & 1); //将下一个点涂成不同颜色
            if (!flag)                           //涂色不成功
                return 0;                        //就结束搜索，返回false
        }
    }

    return 1;
}
int main()
{
    n = read(), m = read();
    for (int i = 1; i <= m; i++)
    {
        int x = read(), y = read();
        G[x].push_back(y); //无向图
        G[y].push_back(x);
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i)
        if (!vis[i]) //如果该点没被标记
        {

            t[0] = t[1] = 0; //先将颜色数归零
            bool flag = dfs(i, 0);

            if (!flag)
            {
                cout << "Impossible";
                return 0;
            }
            ans += min(t[0], t[1]); //答案加上颜色数小的那个
        }
    cout << ans;
    return 0;
}

学习目标

掌握图的基本概念
掌握图的一些性质

图的概念

基本概念

图 (Graph) 是一个二元组 $G = (V (G), E (G))$ 。其中 $V (G)$ 是非空集，称为 点集 (Vertex set) ，对于 $V$ 中的每个元素，我们称其为 顶点 (Vertex) 或 节点 (Node) ，简称点； $E (G)$ 为 $V (G)$ 各结点之间边的集合，称为 边集 (Edge set) 。

常用 $G = (V, E)$ 表示图。

当 $V, E$ 都是有限集合时，称 $G$ 为 有限图 。

当 $V$ 或 $E$ 是无限集合时，称 $G$ 为 无限图 。

图有多种，包括 无向图 (Undirected graph) ， 有向图 (Directed graph) ， 混合图 (Mixed graph) 等

若 G 为无向图，则 E 中的每个元素为一个无序二元组 (u, v) ，称作 无向边 (Undirected edge) ，简称 边 (Edge) ，其中 $\in V$ 。设 $e=(u,v) $，则 $u$ 和 $v$ 称为 $e$ 的 端点 (Endpoint) 。

若 $G$ 为有向图，则 $E$ 中的每一个元素为一个有序二元组 $(u, v)$ ，有时也写作 $\to v$ ，称作 有向边 (Directed edge) ，在不引起混淆的情况下也可以称作 边 (Edge) 。设 $\to v$ ，则此时 u 称为 e 的 起点 (Tail) ， $v$ 称为 $e$ 的 终点 (Head) ，起点和终点也称为 $e$ 的 端点 (Endpoint) 。并称 $u$ 是 $v$ 的直接前驱， $v$ 是 $u$ 的直接后继。

若 $G$ 为混合图，则 $E$ 中既有向边，又有无向边。

若 $G$ 的每条边 $e_k=(u_k,v_k)$ 都被赋予一个数作为该边的权，则称 GG 为 赋权图 。如果这些权都是正实数，就称 $G$ 为 正权图 。

图 $G 的点数 $ $\left| V(G) \right|$ 也被称作图 GG 的 阶 (Order) 。

形象地说，图是由若干点以及连接点与点的边构成的。

图上的关系

点与点——邻接

在无向图 $G = (V, E)$ 中，对于两顶点 u 和 v ，若存在边 $(u, v)$ ，则称 u 和 v 是 相邻（邻接）的 。

一个顶点 $ v \in V$的 邻域 (Neighborhood) 是所有与之相邻的顶点所构成的集合，记作 $N (v)$ 。

PS：邻接表存储的就是邻域，并且由此得名。

点与边——关联

在无向图 $G = (V, E)$ 中，若点 v 是边 e 的一个端点，则称 v 和 e 是 **关联的 **。

度数

与一个顶点 v 关联的边的条数称作该顶点的 度 (Degree) ，记作 $d (v)$ 。特别地，对于边 $(v, v)$ ，则每条这样的边要对 $d (v)$ 产生 22 的贡献。

对于无向简单图，有 $\left| N(v) \right|$ 。

在有向图 $G = (V, E)$ 中，以一个顶点 v 为起点的边的条数称为该顶点的 出度 (Out-degree) ，记作 $d^+(v)$ 。以一个顶点 v 为终点的边的条数称为该节点的 入度 (In-degree) ，记作 $d^-(v)$ 。显然 $d^+(v)+d-(v)=d(v) $。

简单图

自环 (Loop) ：对 E 中的边 $e = (u, v)$ ，若 $u = v$ ，则 e 被称作一个自环。

重边/平行边 (Multiple edge) ：若 EE 中存在两个完全相同的元素（边） $e_1, e_2$ ，则它们被称作（一组）重边。

简单图 (Simple graph) ：若一个图中 没有自环和重边，它被称为简单图。非空简单无向图中一定存在度相同的结点。

如果一张图中有自环或重边，则称它为 多重图 (Multigraph) 。

在无向图中 (u, v) 和 (v, u) 算一组重边，而在有向图中， u→v 和 v→u 不为重边。

在题目中，如果没有特殊说明，是可以存在自环和重边的，在做题时需特殊考虑。

路径

途径 (Walk) / 链 (Chain) ：一个点和边的交错序列，其中首尾是点—— $v_0, e_1, v_1, e_2, v_2, \ldots, e_k, v_k$ ，有时简写为 $v_0 \to v_1 \to v_2 \to \cdots \to v_k$ 。其中 $e_i$ 的两个端点分别为 $v_{i-1}$ 和 $v_i$ 。通常来说，边的数量 k 被称作这条途径的长度（如果边是带权的，长度通常指路径上的边权之和，题目中也可能另有定义）。（以下设 $\left[ v_0, e_1, v_1, e_2, v_2, \cdots, e_k, v_k \right]$ 。)