图的遍历与拓扑排序

最新推荐文章于 2023-05-18 22:56:48 发布
最新推荐文章于 2023-05-18 22:56:48 发布
阅读量157 收藏
点赞数
分类专栏： 套题 文章标签： c++ 算法 拓扑排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b_b_lai_lai/article/details/118250318
版权

A - A Knight’s Journey

在这里插入图片描述
在这里插入图片描述

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;

int visited[27][27];  //用于标记某一位置是否走过
int N, p, q;
int sum;        //用于判断临界条件
int visiting;   //记录已走的步数与sum比较
int Count = 0;  //记录样例的顺序
int flag = 0;   //判断是否找到路
struct path {
    int p;
    int q;
};

path ans[1000];

void dfs(int i, int j) {
    if (i > p || i < 1)
        return;  //临界条件
    if (j > q || j < 1)
        return;
    if (visited[i][j] == 1)
        return;
    visited[i][j] = 1;
    visiting++;
    ans[visiting].p = i, ans[visiting].q = j;
    if (visiting == sum) {
        flag = 1;
        for (int k = 1; k <= visiting; k++) {
            printf("%c%d", ans[k].q - 1 + 'A', ans[k].p);
        }
        return;
    }
    if (flag)
        return;  // j按照从小到大顺序
    dfs(i - 1, j - 2);
    if (flag)
        return;
    dfs(i + 1, j - 2);
    if (flag)
        return;
    dfs(i - 2, j - 1);
    if (flag)
        return;
    dfs(i + 2, j - 1);
    if (flag)
        return;
    dfs(i - 2, j + 1);
    if (flag)
        return;
    dfs(i + 2, j + 1);
    if (flag)
        return;
    dfs(i - 1, j + 2);
    if (flag)
        return;
    dfs(i + 1, j + 2);
    visited[i][j] = 0;
    visiting--;
}

int main() {
    cin >> N;
    while (N--) {
        cin >> p >> q;
        memset(visited, 0, sizeof(visited));  //初始化条件
        sum = p * q;
        Count++;
        flag = 0;
        printf("Scenario #%d:\n", Count);
        for (int i = 1; i <= p; i++) {
            for (int j = 1; j <= q; j++) {
                visiting = 0;
                dfs(i, j);
            }
        }

        if (flag == 0)
            cout << "impossible";
        if (N != 0)
            cout << endl << endl;
    }
    return 0;
}

题解：用dfs按字典序每一个格子一个一个地搜。

B - Dungeon Master

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;
const int N = 40;
int l, r, c;
int flag;
char a[N][N][N], s[N];
bool vis[N][N][N];
int dx[10] = {0, 0, -1, 1, 0, 0};
int dy[10] = {-1, 1, 0, 0, 0, 0};
int dz[10] = {0, 0, 0, 0, -1, 1};
struct node {
    int x, y, z;
    int num;
    friend bool operator<(node a, node b) { return a.num > b.num; }
} sta;
priority_queue<node> q;
void bfs() {
    sta.num = 0;
    q.push(sta);
    while (q.size()) {
        node t = q.top();
        q.pop();
        int nx = t.x, ny = t.y, nz = t.z;
        if (a[nz][ny][nx] == 'E') {
            flag = 1;
            cout << "Escaped in " << t.num << " minute(s)." << endl;
            return;
        }
        for (int i = 0; i < 6; ++i) {
            int nx = t.x + dx[i];
            int ny = t.y + dy[i];
            int nz = t.z + dz[i];

            if (nx > 0 && ny > 0 && nz > 0 && nx <= c && ny <= r && nz <= l &&
                !vis[nz][ny][nx] && !flag) {
                vis[nz][ny][nx] = true;
                node d;
                d.x = nx, d.y = ny, d.z = nz, d.num = t.num + 1;
                q.push(d);
            }
        }
    }
}
int main() {
    while (1) {
        scanf("%d%d%d", &l, &r, &c);
        if (l == 0 && r == 0 && c == 0)
            break;
        flag = 0;
        memset(vis, false, sizeof(vis));
        for (int i = 1; i <= l; ++i)
            for (int j = 1; j <= r; ++j) {
                scanf("%s", s + 1);
                for (int k = 1; k <= c; ++k) {
                    if (s[k] == 'S')
                        sta.z = i, sta.x = k, sta.y = j, vis[i][j][k] = true;
                    if (s[k] == '#')
                        vis[i][j][k] = true;
                    a[i][j][k] = s[k];
                }
            }
        bfs();
        if (flag == 0)
            cout << "Trapped!" << endl;
    }

    return 0;
}

题解：这里也是遍历，不过是bfs遍历，而且是三维的，而且是bfs+优先队列，模板题。

C - Gym Class

题目链接
在这里插入图片描述
在这里插入图片描述

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int M = 100010;
int n, t, m;
int tot, maxx;
int ver[M], Next[M], head[M];
int deg[M];
int as[M], pre;
void add(int x, int y) {  //链式前向星
    ver[++tot] = y;
    Next[tot] = head[x];
    head[x] = tot;
}
void Toposort() {
    priority_queue<int> q;
    for (int i = 1; i <= n; ++i)
        if (deg[i] == 0)
            q.push(i);

    while (!q.empty()) {
        int k = q.top();
        as[pre++] = k;
        q.pop();
        for (int i = head[k]; i; i = Next[i]) {
            deg[ver[i]]--;
            if (deg[ver[i]] == 0)
                q.push(ver[i]);
        }
    }
}

int main() {
    cin >> t;
    while (t--) {
        scanf("%d%d", &n, &m);
        int a, b;
        maxx = 0, tot = 0, pre = 0;
        memset(ver, 0, sizeof(ver));
        memset(Next, 0, sizeof(Next));
        memset(head, 0, sizeof(head));
        memset(deg, 0, sizeof(deg));
        for (int i = 0; i < m; ++i) {
            scanf("%d%d", &a, &b);
            add(a, b);
            deg[b]++;
        }
        Toposort();
        int minn = 0x7fffffff;
        ll sum = 0;
        for (int i = 0; i < n; ++i) {
            minn = min(minn, as[i]);
            sum += minn;
        }
        cout << sum << endl;
    };
    return 0;
}

用了优先队列+拓扑排序还有链式前向星。

D - 逃生

题目链接
在这里插入图片描述
在这里插入图片描述

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int M = 100010;
int n, t, m;
int tot, maxx;
int ver[M], Next[M], head[M];
int deg[M];
int as[M], pre;
void add(int x, int y) {  //链式前向星
    ver[++tot] = y;
    Next[tot] = head[x];
    head[x] = tot;
}
void Toposort() {
    priority_queue<int, vector<int>, less<int> > q;
    for (int i = 1; i <= n; ++i)
        if (deg[i] == 0)
            q.push(i);

    while (!q.empty()) {
        int k = q.top();
        as[pre++] = k;
        q.pop();
        for (int i = head[k]; i; i = Next[i]) {
            deg[ver[i]]--;
            if (deg[ver[i]] == 0)
                q.push(ver[i]);
        }
    }
}

int main() {
    cin >> t;
    while (t--) {
        scanf("%d%d", &n, &m);
        int a, b;
        maxx = 0, tot = 0, pre = 0;
        memset(ver, 0, sizeof(ver));
        memset(Next, 0, sizeof(Next));
        memset(head, 0, sizeof(head));
        memset(deg, 0, sizeof(deg));
        for (int i = 0; i < m; ++i) {
            scanf("%d%d", &a, &b);
            add(b, a);
            deg[a]++;
        }
        Toposort();

        for (int i = n - 1; i > 0; --i) {
            cout << as[i] << ' ';
        }
        cout << as[0] << endl;
    }
    return 0;
}

题解：不可以直接上小根堆，因为无法保证一个序列前面小的后面一定会小，当一个序列后面小的它一定会小。转载于这里

E - Ponds

题目链接
在这里插入图片描述
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e4 + 100;
vector<int> G[maxn];
int vis[maxn];
int degree[maxn];
ll sum1;
int num[maxn];
int n, m;
int count_;

void init(int n) {
    for (int i = 1; i <= n; i++)
        G[i].clear();
    memset(vis, 0, sizeof(vis));
    memset(degree, 0, sizeof(degree));
}

void topcode() {
    queue<int> Q;
    for (int i = 1; i <= n; i++) {
        if (degree[i] <= 1) {
            vis[i] = 1;
            Q.push(i);
        }
    }
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            if (!vis[v]) {
                degree[v]--;
                if (degree[v] <= 1) {
                    vis[v] = 1;
                    Q.push(v);
                }
            }
        }
    }
}

void dfs(int u) {
    vis[u] = 1;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (vis[v] == 0) {
            sum1 += num[v];
            count_++;
            dfs(v);
        }
    }
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n, &m);
        init(n);
        for (int i = 1; i <= n; i++)
            scanf("%d", &num[i]);
        int u, v;
        for (int i = 0; i < m; i++) {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
            degree[u]++;
            degree[v]++;
        }
        topcode();
        ll sum = 0;
        for (int i = 1; i <= n; i++) {
            if (vis[i] == 0) {
                sum1 = num[i];
                count_ = 1;
                dfs(i);
                if (count_ & 1)
                    sum += sum1;
            }
        }
        printf("%I64d\n", sum);
    }
    return 0;
}

题解：因为是双向流通，所以一条边可以同时对两边都产生一个入度，所以先用拓扑排序把入度小于1的边点都去掉；然后再用dfs对每一个点进行遍历，看看是否会产生奇数个点的环。

[HAOI2016]食物链

题目链接
在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int N = 1008611;
int n, m, f[N], rd[N];
vector<int> e[N];

inline int JI_DE_DIAN_GE_ZAN() {
    queue<int> q;
    int ans = 0;
    for (int i = 1; i <= n; i++)
        if (!rd[i] && e[i].size())  // 单个点不算方案
            q.push(i), f[i] = 1;

    while (!q.empty()) {
        int x = q.front();
        q.pop();
        if (!e[x].size())
            ans += f[x];
        for (auto t : e[x]) {
            f[t] += f[x], rd[t]--;  // f来统计方案
            if (!rd[t])
                q.push(t);
        }
    }
    return ans;
}  // 裸的

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m;
    for (int i = 1, x, y; i <= m; i++) {
        cin >> x >> y;
        rd[y]++;
        e[x].push_back(y);
    }
    cout << JI_DE_DIAN_GE_ZAN();
    return ~~(0 ^ 0);
}

题解：真正关键点是这个DAG图，所以可以利用拓扑排序的一些小细节来算（其实我感觉和拓扑排序没啥关系），保存好每个点的入度，然后从入度为0的结点出发（这一步还是和拓扑排序一样），然后遇到每个指向的结点都把自身的权值加到指向的结点权值上面去，遍历到最终结点（即出度为0）就用ans把权值都加起来，点的权值是只通过自身能产生多少条食物链。题解链接

1192. 奖金

题目链接

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 10010, M = 20010;

int n, m;
int h[N], e[M], ne[M], idx;
int q[N];
int d[N];
int dist[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool topsort() {
    int hh = 0, tt = -1;
    for (int i = 1; i <= n; i++)
        if (!d[i])
            q[++tt] = i;

    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (--d[j] == 0)
                q[++tt] = j;
        }
    }

    return tt == n - 1;
}

int main() {
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    while (m--) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);
        d[a]++;
    }

    if (!topsort())
        puts("Poor Xed");
    else {
        for (int i = 1; i <= n; i++)
            dist[i] = 100;
        for (int i = 0; i < n; i++) {
            int j = q[i];
            for (int k = h[j]; ~k; k = ne[k])
                dist[e[k]] = max(dist[e[k]], dist[j] + 1);
        }

        int res = 0;
        for (int i = 1; i <= n; i++)
            res += dist[i];

        printf("%d\n", res);
    }

    return 0;
}

题解：拓扑排序的逆向过程，就是先把后面的元素选出来，再选前面的元素。实现的过程就是建图的时候反过来建图。这题还有一个点要注意，就是要最后枚举所有的边来确定到底是选择哪一条边可以使得奖金最少。

b_b_lai_lai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的遍历-拓扑排序
ring__的博客
01-25 719
问题描述：修一门课程之前必须修完该课程的先修课程，给出一个可行的选课顺序。（可能会有几种不同方案） 课程代号 v1 v2 v3 v4 v5 v6 先修课程 v1、v3 v1 v1、v6 v3、v4、v6 以上问题可以抽象为如下有向无环图的拓扑排序结果： 上图的邻接表为： 1、概念 拓扑排序（topological sort），将一个有向无环图（Directed Acyclic Grap...
c++课程设计-图的遍历和拓扑排序
09-07
XXX大学数据结构课程设计，由个人完成，为大家提供参考。
图的遍历、拓扑排序、最短路径算法
weixin_33875839的博客
08-04 249
1.DFS（深度优先搜索） 深度优先搜索算法（Depth-First-Search），是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。DFS 属...
图、图的遍历及图的拓扑排序
qq_46118239的博客
09-07 339
图、图的遍历及图的拓扑排序
****** 三 ******、软设笔记【数据结构】-图、图的遍历、拓扑排序
weixin_34357928的博客
05-10 64
一、图 图G是由两个集合V和E构成的二元组，记作G+(V，E)，其中V是图中顶点的非空有限集合，E是图中边的有限集合。 *有向图：图G中的每条边都是有方向的，顶点间的关系用<vi，vj>表示； *无向图：图G中的每条边都是无方向的；顶点间的关系用<vi，vj>表示； *完全图：图G任意两个顶点...
图的遍历——拓扑排序
我曾将青春翻涌成她 也曾指尖码出盛夏
11-10 431
背景知识 拓扑排序就是对有向无环图，将所有顶点排成一个线性序列，该序列满足：如果图里有边&amp;lt;u,v&amp;gt;&amp;lt;u,v&amp;gt;&lt;u,v&gt;，那么在该序列里，u一定要在v前面 算法思想 找到入度为0的点（有向无环图中必定存在！），挨个输出（可能不止一个） 删除这些入度为0的点，并且删除以这些点为起点的边 这样又会出现新的一波入度为0点，输出！ 然后...
图的存储遍历拓扑排序
04-09
9. **挑战与提高**：除了基础概念，还可以研究Kahn算法、Tarjan算法等拓扑排序的优化方法，以及如何在复杂图结构中应用图的遍历和排序。 总之，这个资源包提供了全面的图论学习材料，无论是对初学者还是进阶者，都...
数据结构课程设计 图的遍历和拓扑排序
06-18
本次课程设计的重点是“图的遍历”和“拓扑排序”，这两个主题都是图论在数据结构中的具体应用。 **图的遍历** 图是由顶点（vertices）和边（edges）构成的数据结构，用于表示对象之间的关系。在图的遍历中，我们...
c++图的存储与遍历及拓扑排序.ppt
07-13
c++图的存储与遍历及拓扑排序.ppt
数据结构图的遍历及拓扑排序
05-31
/*----------------输出拓扑排序-------------*/ int topsort(linkmap *map) { int k=0,i,j,v,tag[100];//tag用来标记是否已访问到 int queue[100];//用队列存储 int front=0,real=0; edgenode *p; for(i=0;i...
搜索与图论——树与图的遍历：拓扑排序
CSDN729180099的博客
08-26 632
1.树与图的存储 树是一种特殊的图，与图的存储方式相同。 对于无向图中的边ab，存储两条有向边a->b, b->a。 因此我们可以只考虑有向图的存储。 (1) 邻接矩阵：g[a][b] 存储边a->b (2) 邻接表： // 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点 int h[N], e[N], ne[N], idx; // 添加一条边a->b void add(int a, int b) { e[idx] = b, ne[idx
图系列（二）图的遍历与拓扑排序
zhaoyangyingmu的博客
08-18 672
图的遍历与拓扑排序 好了，接下来是重中之重图的遍历。图遍历是很多其他算法的基础，比如Dijkstra算法。 图的遍历 广度优先遍历 广度优先遍历的关键是需要借助一个队列。代码如下： class Solution { List<Integer>[] adjs; public void bfs(int n, int[][] edges) { //...
【数据结构与算法】图的遍历与拓扑排序
qq_66314292的博客
05-12 1212
图的DFS、BFS，拓扑排序
【图论】图的存储、遍历与拓扑排序
BZ_C25LX 的博客
05-18 398
5月16-5月18日学习内容。
c++ 搜索与图的遍历及拓扑排序
Pbw_666的博客
01-30 901
DFS   DFS在搜索中，拥有的空间复杂度与树(解空间构成的搜索数)的高度成正比，但是搜索的点不具有“最短路”的概念。 //算法框架 void dfs(int n){ if(搜索结束){ 记录结果。 return; } for(遍历所有解){ if(合法的解){ 占位。 } dfs(n+1); 取消占位。 } } BFS   BFS在搜索中，需要大量空间是树(解空间构成的搜索数)的高度的指
超级容易理解的图的遍历和拓扑排序
weixin_52220998的博客
08-05 185
图的遍历和拓扑排序
DFS与BFS|树与图的遍历：拓扑排序
weixin_49449676的博客
04-21 635
蓝色部分是结点4的子树，红色部分我们暂时称为其他部门，因为我们知道树的总结点数n，只要能算出蓝色部分的数目s，那么其他部分的数目就是n-s。若删除结点3，剩下一个数目为1的子树，和一个数目为7的子树，即剩下的最大连通子树的结点数目为7……如这里的1，2，3就是拓扑序列，因为1在2前面，2在3前面，1也在3前面。若删除结点2，则剩下两个数目为1的子树和一个数目为6的子树，即剩下的最大连通子树的结点数目为6；若删除结点1，则剩下三个子树最大的是中间那颗结点有4个，即剩下的最大连通子树的结点数目为4；
树与图的遍历 拓扑排序
xuemengliyou的博客
01-13 279
树与图的遍历
树与图的遍历--图的拓扑排序
qq_42828183的博客
07-08 287
1.题目 给定一个n个点m条边的有向图，点的编号是1到n，图中可能存在重边和自环。 请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出-1。 若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。 输入格式 第一行包含两个整数n和m 接下来m行，每行包含两个整数x和y，表示存在一条从点x到点y的有向边(x, y)。 输出格式 共一行，如果存在拓扑序列，则输出拓扑序列。 否则输出-1。 数据范围 1≤n,m≤1051≤n,m≤105 输
深度优先遍历与拓扑排序
最新发布
09-13
深度优先遍历和拓扑排序在图论中有一定的关联...综上所述，深度优先遍历和拓扑排序在有向无环图中有一定的关系，深度优先遍历可以用来实现拓扑排序，并且拓扑排序的结果具有唯一性的条件是所有顶点之间都具有全序关系。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值