聪明办法和笨办法差多少

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

七个构建任务编号 0～6，(a, b) 表示 a 做完才能做 b。

左边是拓扑排序数出来的减法次数。右边数一数笨办法要做多少次检查：把七个任务的全部排列都试一遍，每个排列逐条验七条依赖。

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

提交你的答案

请登录后提交答案。

去登录

← 拓扑排序做了多少次减法点数翻倍代价翻几倍 →

更多题目

代码编辑器

语言： Ctrl + Enter 运行

#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;

using Edges = vector<pair<int, int>>;
const int N = 7;
// 七个构建任务，(a, b) 表示 a 做完才能做 b
const Edges DEP = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}, {4, 5}, {4, 6}};
// 同一张图再加一条 5 → 3，于是有了环
const Edges G = {{0, 1}, {0, 2}, {1, 3}, {2, 3}, {3, 4}, {4, 5}, {5, 3}, {4, 6}};

vector<vector<int>> build(const Edges& edges, int n = N) {
    vector<vector<int>> g(n);
    for (auto [a, b] : edges) g[a].push_back(b);
    for (auto& adj : g) sort(adj.begin(), adj.end());
    return g;
}

// 数一数 Kahn 里「入度减 1」一共做了多少次
int kahn_cost(const Edges& edges, int n = N) {
    vector<vector<int>> g = build(edges, n);
    vector<int> d(n, 0);
    for (auto [a, b] : edges) d[b]++;
    priority_queue<int, vector<int>, greater<int>> ready;
    for (int u = 0; u < n; u++) {
        if (d[u] == 0) ready.push(u);
    }
    int steps = 0;
    while (!ready.empty()) {
        int u = ready.top();
        ready.pop();
        for (int v : g[u]) {
            d[v]--;
            steps++;
            if (d[v] == 0) ready.push(v);
        }
    }
    return steps;
}

// 笨办法：枚举全部排列，每个排列把七条依赖各检查一次，只数次数
long long brute_cost() {
    vector<int> p(N);
    iota(p.begin(), p.end(), 0);
    long long steps = 0;
    do {
        // TODO: 每个排列要把 DEP 里的每一条依赖各检查一次，每检查一条 steps 加 1
    } while (next_permutation(p.begin(), p.end()));
    return steps;
}

int main() {
    cout << kahn_cost(DEP) << "/" << brute_cost() << endl;
}

本次输入：

输出：

👩‍🏫

💬 题目评论

聪明办法和笨办法差多少

更多题目

全部评论