UVa 11680 Dragster

原创于 2025-11-24 17:23:38 发布 · 837 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

动态规划专栏收录该内容

133 篇文章

订阅专栏

题目分析

本题是一个基于树形结构的概率计算问题，涉及淘汰赛制锦标赛。我们需要计算特定选手（ $Rubens\texttt{Rubens}$ ，编号为 $1$ ）赢得整个锦标赛的概率。

问题特点

淘汰赛制：比赛采用单败淘汰制，每场比赛只有一名胜者
概率矩阵：给出了任意两名选手之间的胜负概率
树形结构：比赛过程可以表示为一棵二叉树
复杂编号：选手编号为 $1$ 到 $N$ ，比赛编号为 $N + 1$ 到 $\times N - 1$

输入格式解析

第一行：整数 $N$ 表示选手数量
接下来 $N$ 行： $\times N$ 的概率矩阵， $M [i] [j]$ 表示选手 $i$ 战胜选手 $j$ 的概率
接下来 $N - 1$ 行：比赛描述，每行两个整数表示比赛的双方

关键难点：比赛描述中的编号如果大于 $N$ ，表示引用之前某场比赛的胜者。具体来说，编号 $k$ （ $k > N$ ）表示第 $k - N$ 行描述的比赛。

解题思路

核心算法：树形动态规划

我们使用深度优先遍历（ $DFS\texttt{DFS}$ ）结合动态规划来解决这个问题。

状态定义

设 $w in P ro b [u] [i]$ 表示在节点 $u$ 所代表的子树中，选手 $i$ 能够到达节点 $u$ 的概率。

如果 $u$ 是叶子节点（选手节点），则：
- $w in P ro b [u] [u] = 1.0$ （该选手肯定能到达自己）
- $w in P ro b [u] [j] = 0.0$ （对于 $\neq u$ ）
如果 $u$ 是内部节点（比赛节点），则选手 $i$ 能够到达 $u$ 有两种情况：
1. 选手 $i$ 来自左子树并赢得与右子树胜者的比赛
2. 选手 $i$ 来自右子树并赢得与左子树胜者的比赛

状态转移

对于比赛节点 $u$ ，设其左右子节点分别为 $l e f t$ 和 $r i g h t$ ：

$\sum_{j=1}^{N} \left(winProb[left][i] \times winProb[right][j] \times prob[i][j]\right) + \sum_{j=1}^{N} \left(winProb[right][i] \times winProb[left][j] \times prob[i][j]\right)$

解释：

第一项：选手 $i$ 从左子树晋级，并战胜右子树中的所有可能对手 $j$
第二项：选手 $i$ 从右子树晋级，并战胜左子树中的所有可能对手 $j$

算法步骤

读取输入：包括选手数量、概率矩阵和比赛描述
构建比赛树：
- 选手编号： $1$ 到 $N$
- 比赛编号： $N + 1$ 到 $\times N - 1$
- 为每个比赛节点建立子节点关系
寻找根节点：没有父节点的比赛节点即为根节点
执行 $DFS\texttt{DFS}$ ：从根节点开始进行深度优先遍历，计算概率
输出结果： $w in P ro b [roo t] [1]$ 即为Rubens获胜的概率

时间复杂度

状态数量： $O(N^2)$
状态转移： $O(N^2)$
总时间复杂度： $O(N^4)$ ，在 $\leq 300$ 的情况下可以通过

代码实现

// Dragster
// UVa ID: 11680
// Verdict: Accepted
// Submission Date: 2025-11-24
// UVa Run Time: 0.130s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

const int MAXN = 605;
vector<int> children[MAXN];
double prob[MAXN][MAXN];
double winProb[MAXN][MAXN];
int n;

void dfs(int u) {
    if (u <= n) {
        for (int i = 1; i <= n; i++) winProb[u][i] = 0.0;
        winProb[u][u] = 1.0;
        return;
    }
    
    int left = children[u][0];
    int right = children[u][1];
    dfs(left);
    dfs(right);
    
    for (int i = 1; i <= n; i++) winProb[u][i] = 0.0;
    
    for (int i = 1; i <= n; i++) {
        if (winProb[left][i] > 0) {
            double sum = 0.0;
            for (int j = 1; j <= n; j++)
                sum += winProb[right][j] * prob[i][j];
            winProb[u][i] += winProb[left][i] * sum;
        }
    }
    
    for (int i = 1; i <= n; i++) {
        if (winProb[right][i] > 0) {
            double sum = 0.0;
            for (int j = 1; j <= n; j++)
                sum += winProb[left][j] * prob[i][j];
            winProb[u][i] += winProb[right][i] * sum;
        }
    }
}

int main() {
    while (cin >> n && n) {
        for (int i = 1; i <= 2 * n; i++) children[i].clear();
        
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                cin >> prob[i][j];
        
        vector<pair<int, int>> matches(n - 1);
        for (int i = 0; i < n - 1; i++)
            cin >> matches[i].first >> matches[i].second;
        
        vector<bool> hasParent(2 * n + 1, false);
        
        for (int i = 0; i < n - 1; i++) {
            int raceId = n + 1 + i;
            int left = matches[i].first;
            int right = matches[i].second;
            
            children[raceId].push_back(left);
            children[raceId].push_back(right);
            hasParent[left] = true;
            hasParent[right] = true;
        }
        
        int root = 0;
        for (int i = n + 1; i <= 2 * n - 1; i++) {
            if (!hasParent[i]) {
                root = i;
                break;
            }
        }
        
        dfs(root);
        cout << fixed << setprecision(6) << winProb[root][1] << endl;
    }
    return 0;
}