Keep on the Right Track(拓扑排序 + 期望 DP)

Keep on the Right Track(拓扑排序 + 期望 DP)

一、题目描述

给定一个 n 个点、m 条边的有向无环图,每条边有正权值(通行时间)。每个城市 i 有一个信号状态 s[i](1 表示有信号,0 表示无信号)。

从任意城市出发,前往首都 t。每到一个非 t 的城市 u,按以下规则选择下一条边:

  • 有信号(s[u] = 1):导航系统在 u 到 t 的所有最短路中等概率随机选一条,走它的第一条边
  • 无信号(s[u] = 0):在 u 的所有出边中等概率随机选一条

每次走完一条边到下一个城市后,重新做选择。所有随机选择独立。

求:从每个城市 s 出发,到达 t 的期望总时间,对 998244353 取模。

对应题目:CCPC Online Contest 2026 Problem K

二、思路分析

关键观察

这是一个 DAG,所以可以从 t 出发倒着推期望。

设 E[u] 表示从城市 u 出发到达 t 的期望总时间。

  • E[t] = 0
  • 对于其他城市,E[u] 由它的出边决定

需要预处理的东西

在有信号的城市,概率与「最短路条数」有关,所以需要先求出:

  1. dist[u]:从 u 到 t 的最短距离
  2. cnt[u]:从 u 到 t 的最短路条数

这两个都可以在 DAG 上倒着 DP 求出来。

无信号城市的期望

如果 s[u] = 0,从 u 出发等概率走每条出边:

E[u] = (1 / outdeg(u)) × Σ (w + E[v])

其中 outdeg(u) 是 u 的出度,Σ 遍历所有出边 u -> v(权值 w)。

有信号城市的期望

如果 s[u] = 1,导航只在最短路上随机选择。

对于出边 u -> v(权值 w):

  • 如果 dist[u] == w + dist[v],说明这条边在最短路上
  • 这条边被选中的概率 = cnt[v] / cnt[u](走这条边能到达 t 的最短路条数 / 从 u 出发的最短路总条数)

所以:

E[u] = Σ (cnt[v] / cnt[u]) × (w + E[v])

其中 Σ 只遍历满足 dist[u] == w + dist[v] 的出边。

三、算法流程

  1. 读入图,同时建正向邻接表 adj 和反向邻接表 revadj
  2. 用 Kahn 算法求拓扑序 topu
  3. 倒着遍历拓扑序,用 revadj 计算 dist[u] 和 cnt[u]
    • dist[t] = 0,cnt[t] = 1
    • 对于 u 的每条出边 u -> v:
      • 如果 dist[u] + w < dist[v]:更新 dist[v],cnt[v] = cnt[u]
      • 如果 dist[u] + w == dist[v]:cnt[v] += cnt[u]
  4. 再倒着遍历拓扑序,计算 E[u]
    • s[u] = 0:按出度等概率
    • s[u] = 1:按最短路条数比例
  5. 输出 E[1..n]

四、AC 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll MOD = 998244353;
const ll INF = 1e18;

ll pow(ll a, ll b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1) res = res * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return res;
}

ll inv(ll x)
{
    return pow(x, MOD - 2);
}

int main()
{
    int n, m, t;
    cin >> n >> m >> t;

    string s;
    cin >> s;
    s = " " + s;

    vector<vector<pair<int, ll>>> adj(n + 1);     // 正向边
    vector<vector<pair<int, ll>>> revadj(n + 1);  // 反向边

    for (int i = 0; i < m; i++)
    {
        int u, v;
        ll w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        revadj[v].push_back({u, w});
    }

    // 拓扑排序
    vector<int> indeg(n + 1, 0);
    for (int u = 1; u <= n; u++)
        for (auto it : adj[u])
            indeg[it.first]++;

    queue<int> q;
    for (int i = 1; i <= n; i++)
        if (indeg[i] == 0) q.push(i);

    vector<int> topu;
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        topu.push_back(u);
        for (auto it : adj[u])
        {
            int v = it.first;
            indeg[v]--;
            if (!indeg[v]) q.push(v);
        }
    }

    // 求 dist 和 cnt
    vector<ll> dist(n + 1, INF);
    vector<ll> cnt(n + 1, 0);

    dist[t] = 0;
    cnt[t] = 1;

    for (int i = topu.size() - 1; i >= 0; i--)
    {
        int u = topu[i];
        if (dist[u] == INF) continue;
        for (auto it : revadj[u])
        {
            int v = it.first, w = it.second;
            if (dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                cnt[v] = cnt[u];
            }
            else if (dist[u] + w == dist[v])
            {
                cnt[v] = (cnt[v] + cnt[u]) % MOD;
            }
        }
    }

    // 求期望
    vector<ll> exp(n + 1, 0);

    for (int i = (int)topu.size() - 1; i >= 0; i--)
    {
        int u = topu[i];
        if (u == t) continue;

        if (s[u] == '0')
        {
            // 无信号:按出度等概率
            ll sum = 0;
            for (auto it : adj[u])
            {
                int v = it.first;
                ll w = it.second;
                sum = (sum + w + exp[v]) % MOD;
            }
            ll outedge = adj[u].size();
            exp[u] = sum * inv(outedge) % MOD;
        }
        else
        {
            // 有信号:按最短路条数比例
            ll sum = 0;
            for (auto it : adj[u])
            {
                int v = it.first;
                ll w = it.second;
                if (dist[u] == w + dist[v])
                {
                    ll prob = cnt[v] * inv(cnt[u]) % MOD;
                    sum = (sum + prob * ((w + exp[v]) % MOD)) % MOD;
                }
            }
            exp[u] = sum;
        }
    }

    for (int i = 1; i <= n; i++)
    {
        if (i > 1) cout << ' ';
        cout << exp[i] % MOD;
    }
    cout << endl;

    return 0;
}

五、代码说明

1. 建图

同时建正向边 adj 和反向边 revadj:

  • 正向边用于计算期望(从 u 出发看出边)
  • 反向边用于计算 dist 和 cnt(从 t 出发倒推)

2. 拓扑排序

标准 Kahn 算法,得到拓扑序 topu。

3. 计算 dist 和 cnt

dist[t] = 0;
cnt[t] = 1;

for (int i = topu.size() - 1; i >= 0; i--)
{
    int u = topu[i];
    if (dist[u] == INF) continue;
    for (auto it : revadj[u])
    {
        int v = it.first, w = it.second;
        if (dist[u] + w < dist[v])
        {
            dist[v] = dist[u] + w;
            cnt[v] = cnt[u];
        }
        else if (dist[u] + w == dist[v])
        {
            cnt[v] = (cnt[v] + cnt[u]) % MOD;
        }
    }
}
  • 倒着遍历拓扑序,保证算 v 时 u 已经被算过
  • dist[v] 是 v 到 t 的最短距离
  • cnt[v] 是 v 到 t 的最短路条数

4. 计算期望

if (s[u] == '0')
{
    ll sum = 0;
    for (auto it : adj[u])
        sum = (sum + w + exp[v]) % MOD;
    exp[u] = sum * inv(adj[u].size()) % MOD;
}
else
{
    ll sum = 0;
    for (auto it : adj[u])
    {
        if (dist[u] == w + dist[v])
        {
            ll prob = cnt[v] * inv(cnt[u]) % MOD;
            sum = (sum + prob * ((w + exp[v]) % MOD)) % MOD;
        }
    }
    exp[u] = sum;
}
  • 无信号:每条出边等概率,直接除以出度
  • 有信号:只走最短路,概率为 cnt[v] / cnt[u]

六、总结

要点 内容
模型 DAG 上的期望 DP
核心 从 t 倒推,无信号按出度等概率,有信号按最短路条数比例
预处理 先求 dist 和 cnt(最短路距离和条数)
复杂度 O(n + m)
posted @ 2026-10-04 18:24  leaderling  阅读(24)  评论(0)    收藏  举报