洛谷 python P4017 最大食物链计数

两种方法

• • 方法一：深度优先搜索 + 动态规划
  • 方法二：拓扑排序 + 动态规划

方法一：深度优先搜索 + 动态规划

使用动态规划记录中间计算结果，减少不必要的计算。

def main():
    mod = 80112002
    n, m = map(int, input().split())
    # 有向图，消费者 -> 被消费者
    temp = [-1] * n
    edge = [[] for _ in range(n)]
    for _ in range(m):
        p, c = map(lambda x: int(x) - 1, input().split())
        edge[c].append(p)
        temp[p] = c
    
    producers = [i for i, x in enumerate(edge) if len(x) == 0]
    consumers = [i for i, x in enumerate(temp) if x == -1]

    # 记录每个节点的食物链数量
    resVector = [0] * n
    for p in producers:
        resVector[p] = 1

    def dfs(c):
        if resVector[c] == 0:
            for e in edge[c]:
                resVector[c] += dfs(e)
                resVector[c] %= mod
        return resVector[c]
    
    res = 0
    for c in consumers:
        res += dfs(c)
        res %= mod
    print(res)

main()

方法二：拓扑排序 + 动态规划

拓扑排序是一种对有向无环图进行排序的算法，常用于解决具有依赖关系的任务调度问题。
最后一个用例没通过，可以交流下优化。

n, m = map(int, input().split())
# 有向图，消费者 -> 被消费者
edge = [[] for _ in range(n)]
# 记录食物链顶端
cosumer = 0
producer = 0
# 记录节点的入度
points = [0] * n
for i in range(m):
    p, c = map(lambda x: int(x) - 1, input().split())
    edge[c].append(p)
    cosumer |= (1 << p)
    producer |= (1 << c)
    points[p] += 1

# 得到最终消费者和生产者
def getEndPoint(p: int) -> list:
    p ^= (1 << n) - 1
    res = []
    while p > 0:
        temp = p.bit_length() - 1
        res.append(temp)
        p -= (1 << temp)
    return res
cosumers = getEndPoint(cosumer)
producers = getEndPoint(producer)

# 记录每个节点的食物链数量
resVector = [0] * n
for cosumer in cosumers:
    resVector[cosumer] = 1
# 拓扑排序
sortPoint = []
sortPoint.extend(cosumers)
for i in range(n):
    p = sortPoint[i]
    for j in edge[p]:
        points[j] -= 1
        resVector[j] = (resVector[j] + resVector[p]) % 80112002
        if points[j] == 0:
            sortPoint.append(j)

res = 0
for producer in producers:
    res = (res + resVector[producer]) % 80112002
print(res)