UVa 10766 Organising the Organisation

原创已于 2025-10-24 09:41:22 修改 · 666 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #1024程序员节

于 2025-10-15 17:36:48 首次发布

数论专栏收录该内容

70 篇文章

订阅专栏

题目描述

我们有一个包含 $n$ 个部门的公司，需要将这些部门组织成一个树形层次结构。其中一个特定的部门（编号为 $k$ ）必须位于树的根节点位置。此外，某些部门对之间无法直接合作，这意味着在树形结构中它们不能是直接的父子关系。

给定部门数量 $n$ 、中央管理部门编号 $k$ 以及 $m$ 对不能合作的部门，我们需要计算可能的组织方案数量。

问题分析

这个问题可以抽象为：在 $n$ 个节点的完全图中，删除 $m$ 条禁止边后，计算以节点 $k$ 为根的生成树数量。

关键观察

$1$ . 树形结构：公司的组织架构是一棵有根树，根节点固定为中央管理部门 $k$
$2$ . 禁止边约束：某些节点对之间不能有直接的父子关系
$3$ . 生成树计数：这实际上是一个带约束的生成树计数问题

算法选择

Matrix-Tree 定理

Kirchhoff’s Matrix-Tree Theorem 是解决此类问题的经典方法：

对于无向图 $G$ ，其生成树数量等于其拉普拉斯矩阵的任意一个 $n - 1$ 阶主子式的行列式
对于有根树（根固定为 $k$ ），生成树数量等于删除第 $k$ 行第 $k$ 列后的 $n - 1$ 阶矩阵的行列式

拉普拉斯矩阵构造

对于图 $G = (V, E)$ ，拉普拉斯矩阵 $L$ 定义为：

$L_{ii} = \deg(i)$ ，即节点 $i$ 的度数
$L_{ij} = -1$ ，如果 $\in E$
$L_{ij} = 0$ ，如果 $\notin E$

在我们的问题中，图 $G$ 是完全图 $K_n$ 去掉 $m$ 条禁止边。

解题步骤

$1$ . 构建允许边图：从完全图中移除所有禁止边
$2$ . 构造拉普拉斯矩阵：根据允许边图构建拉普拉斯矩阵
$3$ . 删除根节点行列：删除第 $k$ 行和第 $k$ 列，得到 $n - 1$ 阶矩阵
$4$ . 计算行列式：使用整数安全的算法计算该矩阵的行列式

技术难点

整数行列式计算

由于结果可能达到 $10^{15}$ ，必须使用精确的整数运算。浮点数运算会产生精度问题。

我们采用辗转相除法进行高斯消元：

避免除法运算，保持整数精度
通过行交换和减法操作实现消元
每次交换行时调整行列式的符号

算法复杂度

时间复杂度： $O(n^3)$ ，主要来自行列式计算
空间复杂度： $O(n^2)$ ，用于存储矩阵

对于 $\leq 50$ 的数据规模，这个复杂度是完全可行的。

参考代码

// Organising the Organisation
// UVa ID: 10766
// Verdict: Accepted
// Submission Date: 2025-10-15
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

// 使用辗转相除法的高斯消元计算整数行列式
ll det(vector<vector<ll>> matrix) {
    int n = matrix.size();
    ll res = 1;
    
    for (int i = 0; i < n; i++) {
        // 寻找主元
        int pivot = i;
        for (int j = i + 1; j < n; j++) {
            if (abs(matrix[j][i]) > abs(matrix[pivot][i])) {
                pivot = j;
            }
        }
        if (pivot != i) {
            swap(matrix[i], matrix[pivot]);
            res = -res;
        }
        
        if (matrix[i][i] == 0) {
            return 0;
        }
        
        // 消去下方行
        for (int j = i + 1; j < n; j++) {
            while (matrix[j][i] != 0) {
                // 使用辗转相除法
                ll ratio = matrix[j][i] / matrix[i][i];
                for (int k = i; k < n; k++) {
                    matrix[j][k] -= ratio * matrix[i][k];
                }
                
                if (matrix[j][i] != 0) {
                    swap(matrix[i], matrix[j]);
                    res = -res;
                }
            }
        }
        
        res *= matrix[i][i];
    }
    
    return res;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n, m, k;
    while (cin >> n >> m >> k) {
        vector<vector<bool>> forbidden(n, vector<bool>(n, false));
        
        for (int i = 0; i < m; i++) {
            int a, b;
            cin >> a >> b;
            a--; b--;
            forbidden[a][b] = true;
            forbidden[b][a] = true;
        }

        // 构建拉普拉斯矩阵
        vector<vector<ll>> L(n, vector<ll>(n, 0));
        for (int i = 0; i < n; i++) {
            int deg = 0;
            for (int j = 0; j < n; j++) {
                if (i != j && !forbidden[i][j]) {
                    L[i][j] = -1;
                    deg++;
                }
            }
            L[i][i] = deg;
        }

        // 删除第 k-1 行和列
        if (n == 1) {
            cout << "1\n";
            continue;
        }
        
        vector<vector<ll>> minor;
        for (int i = 0; i < n; i++) {
            if (i == k - 1) continue;
            vector<ll> row;
            for (int j = 0; j < n; j++) {
                if (j == k - 1) continue;
                row.push_back(L[i][j]);
            }
            minor.push_back(row);
        }

        ll ans = det(minor);
        cout << ans << "\n";
    }

    return 0;
}