洛谷 P3183 [HAOI2016]食物链(记忆化搜索/拓扑排序)

[HAOI2016]食物链

给定 n 个物种和 m 条能量流动关系，求其中的食物链条数。物种的名称从 1 到 n 编号， M 条能量流动关系形如 a1​→b1​,a2​→b2​,a3​→b3​⋯am−1​→bm−1​,am​→bm​ 其中 ai​→bi​ 表示能量从物种 ai​ 流向物种 bi​ ,注意单独的一种孤立生物不算一条食物链。

食物链：如果从 x 到 y 的某条路径是沿着能量流动方向移动的，并且 x 没有入边, y 没有出边，则该条路径为一条食物链。

题目保证不会出现重复的能量流动关系，并且能量不会环形流动。

显然，题中所给的的是 DAG ，即有向无环图。我们要做的就是统计这个 DAG 中有多少条不同路径 (u,v) 满足 u 没有入边, v 没有出边。注意相同起点与终点之间可能有多条路径。

我们可以考虑使用动态规划来解决这个问题： 设 f[u] 表示从没有入边的点到达点 u 有多少条不同的路径。

• 所有没有入边的点的 f 值应该初始化为 1
• 转移方程为：v​=∑(u,v)∈E​fu​
• 答案计算为： ans=∑outu​=0且inu​=0​fu​ ，其中 outu​ 为点 u 的出度, inu​ 为点 u 的入度

实现这个动态规划有两种方法：记忆化搜索与拓扑排序。

我们首先来看如何用记忆化搜索来实现该算法。

---

记忆化搜索解决 DAG 上 DP

我们观察转移方程： f[v]=∑(u,v)∈E​f[u]

所以在计算一个点时，我们需要递归计算其所有入边，并且将对应点的 f 值累加到该点的 f 值中。所以可以考虑反向建边，这样我们就可以直接通过边表得知一个点应该由哪些点的 f 值来更新。

相应的，由于我们反向建边，最终贡献答案的点需要满足的条件变为：入度为 0 ，并且有出边（如果入度为 0 且没有出边，则该点是一个单独的点）。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 100010; // 点数量
const int maxm = 200010; // 边数量
struct Edge { // 邻接表相关
    int to, next;
} G[maxm];
int head[maxn], cnt, deg[maxn]; // deg 为入度

void addEdge(int u, int v) {
    G[++cnt].to = v;
    G[cnt].next = head[u];
    head[u] = cnt;
    ++deg[v]; // 统计入度
}
int f[maxn];
int dfs(int u){
    if (!head[u]) return 1;
    if (f[u] != -1) return f[u];
    f[u] = 0;
    for(int i = head[u]; i; i = G[i].next){
        int v = G[i].to;
        f[u] += dfs(v);
    }
    return f[u];
}
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v;
    for (int i = 1; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        addEdge(v, u); // 反向建边
    }
    int ans = 0;
    memset(f, -1, sizeof(f));
    for(int i = 1; i <= n;i++){
        if (deg[i] == 0 && head[i]) ans += dfs(i);
    }
    printf("%d\n",ans);
    return 0;
}

---

 拓扑排序解决 DAG 上 DP

观察我们的转移方程：f[v]=∑(u,v)∈E​f[u]

如果有若干条边 u1​→v,u2​→v,⋯uk​→v ，那么只有当 f[u1​],f[u2​],⋯,f[uk​] 全部计算完成时，才可以计算 f[v] 。也即， DAG 中的有向边规定了计算的顺序，只有当一个点的所有前驱点都计算完成时，该点才可以计算。

所以我们需要一个合理的计算顺序，使其满足该图所有的计算顺序要求。

我们可以在这里应用拓扑排序算法来求出拓扑序，然后让方程按照拓扑序进行转移。

与记忆化搜索的把大状态分割为小状态不同，我们使用拓扑序进行转移时采取的方式是将小状态的答案贡献到大状态中。即我们枚举到拓扑序的某一个点 u 时， [u] 已经计算完成，我们需要枚举由该点出发的所有边 (u,v) , 然后将 f[u] 的值贡献到 f[v] 中，即 f[v] += f[u]。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;
const int maxn = 100010; // 点数量
const int maxm = 200010; // 边数量
struct Edge { // 邻接表相关
    int to, next;
} G[maxm];
int head[maxn], cnt, deg[maxn]; // deg 为入度

void addEdge(int u, int v) {
    G[++cnt].to = v;
    G[cnt].next = head[u];
    head[u] = cnt;
    ++deg[v]; // 统计入度
}

int f[maxn], n, m; // f 为dp数组
bool flag[maxn]; // flag 表示在原图中入度是否为 0

int toposort() {
    queue<int> q;
    for(int i = 1; i <= n; i++){
        if (deg[i] == 0){
            flag[i] = true;
            f[i] = 1;
            q.push(i);
        }
    }
    while(!q.empty()){
        int u = q.front();
        q.pop();
        for(int i = head[u]; i ; i = G[i].next){
            int v = G[i].to;
            f[v] += f[u];
            if (--deg[v] == 0) q.push(v); 
        }
    }
    int ans = 0;
    for(int i = 1; i <= n; ++i){
        if(head[i] == 0 && !flag[i])ans += f[i];
    }
    return ans;
}

int main() {
    scanf("%d%d", &n, &m);
    int u, v;
    for (int i = 1; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        addEdge(u, v);
    }
    printf("%d\n", toposort());
    return 0;
}