有向无环图从s出发到t的简单路径条数

最新推荐文章于 2023-02-13 17:12:59 发布

不维护了

最新推荐文章于 2023-02-13 17:12:59 发布

阅读量838

点赞数

分类专栏：算法模板文章标签： dfs 算法图拓扑排序

本文链接：https://blog.csdn.net/DwenKing/article/details/107686306

版权

算法模板专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文深入探讨了深度优先搜索（DFS）和结合拓扑排序与动态规划（DP）的算法实现，通过具体代码示例展示了如何解决特定类型的路径计数问题。文章首先介绍了DFS的基本原理和应用，随后通过拓扑排序优化了路径搜索过程，并结合DP避免重复计算，最终高效求解从起点到终点的所有可能路径数量。

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

DFS

#include <iostream>
#include <vector>
using namespace std;
const int MAX_V = 101;
vector<int> map[MAX_V];
int book[MAX_V];
int st, ed;
int ans = 0;

void dfs(int s) {
    if (s == ed) {
        ans++;
        return;
    }
    for (auto i : map[s]) {
        if (!book[i]) {
            book[i] = 1;
            dfs(i);
            book[i] = 0;
        }
    }
}

int main() {
    int V, m;
    cin >> V >> m;
    cin >> st >> ed;
    while (m--) {
        int a, b;
        cin >> a >> b;
        map[a].push_back(b);
    }
    dfs(st);
    cout << ans;
}

拓扑排序+DP

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX_V = 101;
vector<int> map[MAX_V], a;
int book[MAX_V], deg[MAX_V], dp[MAX_V][MAX_V], e[MAX_V][MAX_V];
int st, ed, V, m;
int ans = 0, flags, flage;

void topo() {
    queue<int> q;
    for (int i = 1; i <= V; i++) {
        if (!deg[i]) {
            q.push(i);
        }
    }
    while (q.size()) {
        int tmp = q.front();
        q.pop();
        a.push_back(tmp);
        if (tmp == st)
            flags = a.end() - a.begin() - 1;
        if (tmp == ed)
            flage = a.end() - a.begin() - 1;
        for (auto i : map[tmp]) {
            deg[i]--;
            if (!deg[i])
                q.push(i);
        }
    }
}

int main() {
    cin >> V >> m;
    cin >> st >> ed;
    while (m--) {
        int a, b;
        cin >> a >> b;
        //存储边数
        e[a][b]++;
        map[a].push_back(b);
        //存储入度
        deg[b]++;
    }
    //topo的结果放在a中
    topo();
    for (int i = 1; i <= V; i++)
        dp[i][i] = 1;
    for (int i = flags + 1; i <= flage; i++) {
        for (int j = flags; j < i; j++) {
            if (e[a[j]][a[i]])
                //注意重边的情况
                dp[st][a[i]] += dp[st][a[j]] * e[a[j]][a[i]];
        }
    }
    cout << dp[st][ed];
}