交付遍历连通最短步

👁️ 1 人浏览 💬 0 人评论 ❤️ 添加收藏

这是这条路线的最终作品。其余函数都已写好，补全 bfs 和 kahn，然后一次验完五条：DFS 与 BFS 走到的点集合相同；这张图 2 块、大小 5 和 2；0 到 4 最少 2 步、路径 0-2-4，DFS 找到的那条要 3 步；网格四连通 4 个岛、八连通 3 个；六门课拓扑序长 6，加一条 5→1 成环后只剩 1。五条全过输出 验收通过，否则输出 验收失败。

本节的图：七个点，边 0-1、0-2、1-3、2-4、3-4、5-6；邻接表 G 里每个点的邻居按编号从小到大排。

本节的网格（四行四列，1 是陆地，0 是海）：1100 / 1001 / 0010 / 1000。

六门课的先修关系：0→2、1→2、2→3、2→4、3→5、4→5（邻接表 COURSE）。

（本题用 g++ -std=c++17 -O0 编译。）

提交你的答案

请登录后提交答案。

去登录

← 第四步网格和拓扑序为什么要用随机数据对拍 →

更多题目

代码编辑器

语言： Ctrl + Enter 运行

#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;

vector<vector<int>> G = {{1, 2}, {0, 3}, {0, 4}, {1, 4}, {2, 3}, {6}, {5}};

void go(const vector<vector<int>>& g, int u, vector<bool>& seen, vector<int>& out) {
    seen[u] = true;
    out.push_back(u);
    for (int v : g[u]) {
        if (!seen[v]) go(g, v, seen, out);
    }
}

vector<int> dfs(const vector<vector<int>>& g, int s) {
    vector<bool> seen(g.size(), false);
    vector<int> out;
    go(g, s, seen, out);
    return out;
}

vector<int> dfs_stack(const vector<vector<int>>& g, int s) {
    vector<bool> seen(g.size(), false);
    vector<int> out;
    vector<int> st = {s};
    while (!st.empty()) {
        int u = st.back();
        st.pop_back();
        if (seen[u]) continue;
        seen[u] = true;
        out.push_back(u);
        for (int v : g[u]) {
            if (!seen[v]) st.push_back(v);
        }
    }
    return out;
}

vector<int> bfs(const vector<vector<int>>& g, int s) {
    // TODO: 队列版 BFS，入队即标记，返回访问顺序
    return {};
}

vector<vector<int>> blocks(const vector<vector<int>>& g) {
    vector<bool> seen(g.size(), false);
    vector<vector<int>> out;
    for (int s = 0; s < (int)g.size(); s++) {
        if (seen[s]) continue;
        vector<int> blk;
        vector<int> st = {s};
        seen[s] = true;
        while (!st.empty()) {
            int u = st.back();
            st.pop_back();
            blk.push_back(u);
            for (int v : g[u]) {
                if (!seen[v]) {
                    seen[v] = true;
                    st.push_back(v);
                }
            }
        }
        sort(blk.begin(), blk.end());
        out.push_back(blk);
    }
    return out;
}

vector<int> dist(const vector<vector<int>>& g, int s) {
    vector<int> d(g.size(), -1);
    queue<int> q;
    d[s] = 0;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v : g[u]) {
            if (d[v] == -1) {
                d[v] = d[u] + 1;
                q.push(v);
            }
        }
    }
    return d;
}

vector<int> bfs_path(const vector<vector<int>>& g, int s, int t) {
    vector<int> par(g.size(), -2);
    queue<int> q;
    par[s] = -1;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v : g[u]) {
            if (par[v] == -2) {
                par[v] = u;
                q.push(v);
            }
        }
    }
    if (par[t] == -2) return {};
    vector<int> path;
    for (int x = t; x != -1; x = par[x]) path.push_back(x);
    reverse(path.begin(), path.end());
    return path;
}

bool dfs_path(const vector<vector<int>>& g, int u, int t, vector<bool>& seen, vector<int>& path) {
    seen[u] = true;
    path.push_back(u);
    if (u == t) return true;
    for (int v : g[u]) {
        if (!seen[v] && dfs_path(g, v, t, seen, path)) return true;
    }
    path.pop_back();
    return false;
}

vector<vector<int>> GRID_MAP = {{1, 1, 0, 0}, {1, 0, 0, 1}, {0, 0, 1, 0}, {1, 0, 0, 0}};
const vector<pair<int, int>> D4 = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const vector<pair<int, int>> D8 = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}};

pair<int, vector<int>> islands(const vector<vector<int>>& g, const vector<pair<int, int>>& dirs) {
    int m = g.size(), n = g[0].size();
    vector<vector<bool>> seen(m, vector<bool>(n, false));
    int cnt = 0;
    vector<int> sizes;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (g[i][j] != 1 || seen[i][j]) continue;
            cnt++;
            vector<pair<int, int>> st = {{i, j}};
            seen[i][j] = true;
            int sz = 0;
            while (!st.empty()) {
                auto [x, y] = st.back();
                st.pop_back();
                sz++;
                for (auto [dx, dy] : dirs) {
                    int a = x + dx, b = y + dy;
                    if (a >= 0 && a < m && b >= 0 && b < n && g[a][b] == 1 && !seen[a][b]) {
                        seen[a][b] = true;
                        st.push_back({a, b});
                    }
                }
            }
            sizes.push_back(sz);
        }
    }
    return {cnt, sizes};
}

vector<vector<int>> COURSE = {{2}, {2}, {3, 4}, {5}, {5}, {}};

vector<int> kahn(const vector<vector<int>>& g) {
    vector<int> d(g.size(), 0);
    for (size_t u = 0; u < g.size(); u++) {
        for (int v : g[u]) d[v]++;
    }
    queue<int> q;
    for (int u = 0; u < (int)g.size(); u++) {
        if (d[u] == 0) q.push(u);
    }
    vector<int> out;
    // TODO: 取出队首记进 out，把下家入度减一，减到 0 的入队
    return out;
}

int main() {
    vector<int> a = dfs(G, 0), b = bfs(G, 0);
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    bool c1 = !a.empty() && a == b;
    vector<vector<int>> bl = blocks(G);
    bool c2 = bl.size() == 2 && bl[0].size() == 5 && bl[1].size() == 2;
    vector<bool> seen(G.size(), false);
    vector<int> dp;
    dfs_path(G, 0, 4, seen, dp);
    bool c3 = dist(G, 0)[4] == 2 && bfs_path(G, 0, 4) == vector<int>{0, 2, 4} && dp.size() == 4;
    bool c4 = islands(GRID_MAP, D4).first == 4 && islands(GRID_MAP, D8).first == 3;
    vector<vector<int>> cyc = COURSE;
    cyc[5].push_back(1);
    bool c5 = kahn(COURSE).size() == 6 && kahn(cyc).size() == 1;
    cout << (c1 && c2 && c3 && c4 && c5 ? "验收通过" : "验收失败") << endl;
}

本次输入：

输出：

👩‍🏫

AI

💬 题目评论

全部评论