UVa 10558 A Brief Gerrymander

原创于 2025-11-24 15:47:30 发布 · 651 阅读

29 ·

CC 4.0 BY-SA版权

文章标签：

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

动态规划专栏收录该内容

136 篇文章

订阅专栏

题目描述

某城市的执政党正在重新划分选区，试图将支持反对党的社区尽可能集中到少数几个选区中。城市被街道和大道划分为网格状，街道是南北方向的边界，大道是东西方向的边界。城市由四条道路围成：第 $1$ 街（西边界）、第 $100$ 街（东边界）、第 $1$ 大道（南边界）、第 $100$ 大道（北边界）。

执政党已经确定了街道边界，但允许反对党选择大道边界。已知所有支持反对党的社区的位置，每个社区位于相邻街道和相邻大道之间的一个街区中。你需要选择 $A$ 条大道边界，使得尽可能多的选区包含至少一个支持反对党的社区。

输入格式

输入包含多个测试用例。每个测试用例的格式如下：

第一行： $N$ ，表示支持反对党的社区数量
接下来 $N$ 行：每行两个整数，表示社区西南角的街道编号和大道编号
下一行： $S$ ，表示街道边界的数量，接着 $S$ 个递增的街道编号
下一行： $A$ ，表示必须放置的大道边界数量（至少为 $2$ ）
输入以 -1 结束

输出格式

对于每个测试用例，输出一行： $A$ ，接着是 $A$ 个递增的大道编号，表示最优划分方案。如果有多个最优解，输出任意一个即可。

题目分析

问题本质

这个问题可以抽象为：在固定街道边界的情况下，选择 $A$ 条大道边界（必须包含 $1$ 和 $100$ ），使得被划分出的选区中，包含至少一个反对党社区的选区数量最大化。

关键观察

选区定义：一个选区是由两条相邻街道和两条相邻大道围成的矩形区域
固定边界：大道边界必须包含 $1$ 和 $100$ ，因此实际需要选择的是 $A - 2$ 条额外的大道边界
价值计算：一个大道区间的价值等于该区间在各个街道区间中，至少包含一个反对党社区的街道区间数量

解题思路

预处理候选大道：
- 收集所有有反对党社区的大道编号
- 排除 $1$ 和 $100$ （因为它们已经固定）
- 对候选大道进行排序
预计算区间价值：
- 构建 hasCommunity 矩阵，记录每个街道区间-大道区间是否包含反对党社区
- 预计算 intervalValue 矩阵，存储任意两个大道之间的区间价值
动态规划求解：
- 状态定义： $d p [k] [j]$ 表示选择 $k$ 条大道边界，最后一条边界是候选列表中第 $j$ 个时的最大价值
- 初始状态：选择第一条大道时，价值为区间 $\text{候选大道}_j)$ 的价值
- 状态转移： $\max(dp[k][j], dp[k-1][i] + \text{intervalValue}[i][j])$
- 最终价值：总价值需要加上最后一个区间 $[最后一条大道,100)[\text{最后一条大道}, 100)$ 的价值
构造解：
- 回溯动态规划路径，得到选择的 $A - 2$ 条大道
- 加上固定的 $1$ 和 $100$ ，按递增顺序输出

算法复杂度

预计算复杂度： $\times M^2)$ ，其中 $S$ 是街道区间数， $M$ 是候选大道数
动态规划复杂度： $\times M^2)$ ，其中 $K$ 是选择的大道数量
总体复杂度在题目约束范围内是可接受的

代码实现

// A Brief Gerrymander
// UVa ID: 10558
// Verdict: Accepted
// Submission Date: 2025-11-24
// UVa Run Time: 0.100s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

int main() {
    int n;
    while (cin >> n, n != -1) {
        vector<pair<int, int>> neighborhoods(n);
        for (int i = 0; i < n; i++) {
            cin >> neighborhoods[i].first >> neighborhoods[i].second;
        }
        
        int s;
        cin >> s;
        vector<int> streets(s);
        for (int i = 0; i < s; i++) cin >> streets[i];
        
        int a;
        cin >> a;

        // 收集候选大道：有社区的大道（排除1和100）
        set<int> candidateSet;
        for (auto& nb : neighborhoods) {
            if (nb.second != 1 && nb.second != 100) {
                candidateSet.insert(nb.second);
            }
        }
        // 添加1和100用于预计算，但选择时排除
        candidateSet.insert(1);
        candidateSet.insert(100);
        vector<int> allAvenues(candidateSet.begin(), candidateSet.end());
        int totalAvenues = allAvenues.size();
        
        // 找到1和100在allAvenues中的位置
        int idx1 = find(allAvenues.begin(), allAvenues.end(), 1) - allAvenues.begin();
        int idx100 = find(allAvenues.begin(), allAvenues.end(), 100) - allAvenues.begin();
        
        // 构建候选大道（排除1和100）
        vector<int> candidates;
        for (int i = 0; i < totalAvenues; i++) {
            if (allAvenues[i] != 1 && allAvenues[i] != 100) {
                candidates.push_back(i);  // 存储索引而不是值
            }
        }
        int m = candidates.size();

        // 预计算：hasCommunity[st][av] 表示街道区间st在大道区间av是否有社区
        vector<vector<bool>> hasCommunity(s - 1, vector<bool>(totalAvenues - 1, false));
        for (auto& nb : neighborhoods) {
            int streetIdx = upper_bound(streets.begin(), streets.end(), nb.first) - streets.begin() - 1;
            if (streetIdx < 0 || streetIdx >= s - 1) continue;
            
            int avenueIdx = upper_bound(allAvenues.begin(), allAvenues.end(), nb.second) - allAvenues.begin() - 1;
            if (avenueIdx >= 0 && avenueIdx < totalAvenues - 1) {
                hasCommunity[streetIdx][avenueIdx] = true;
            }
        }

        // 预计算区间价值矩阵
        vector<vector<int>> intervalValue(totalAvenues, vector<int>(totalAvenues, 0));
        for (int i = 0; i < totalAvenues; i++) {
            for (int j = i + 1; j < totalAvenues; j++) {
                int value = 0;
                for (int st = 0; st < s - 1; st++) {
                    bool covered = false;
                    for (int av = i; av < j; av++) {
                        if (hasCommunity[st][av]) {
                            covered = true;
                            break;
                        }
                    }
                    if (covered) value++;
                }
                intervalValue[i][j] = value;
            }
        }

        // 动态规划：选择A-2条大道
        int selectCount = min(a - 2, m);
        
        vector<vector<int>> dp(selectCount + 1, vector<int>(m, -1));
        vector<vector<int>> prev(selectCount + 1, vector<int>(m, -1));
        
        // 初始化：选择第一条大道（与大道1形成区间）
        for (int j = 0; j < m; j++) {
            dp[1][j] = intervalValue[idx1][candidates[j]];
        }
        
        // DP转移
        for (int k = 2; k <= selectCount; k++) {
            for (int j = k - 1; j < m; j++) {
                for (int i = k - 2; i < j; i++) {
                    if (dp[k - 1][i] != -1) {
                        int newVal = dp[k - 1][i] + intervalValue[candidates[i]][candidates[j]];
                        if (newVal > dp[k][j]) {
                            dp[k][j] = newVal;
                            prev[k][j] = i;
                        }
                    }
                }
            }
        }

        // 找到最优解（考虑最后区间）
        int bestVal = -1, bestIdx = -1;
        if (selectCount == 0) {
            // 如果不需要选择额外大道，只有[1,100)区间
            bestVal = intervalValue[idx1][idx100];
            bestIdx = -1;
        } else {
            for (int j = 0; j < m; j++) {
                if (dp[selectCount][j] != -1) {
                    int totalVal = dp[selectCount][j] + intervalValue[candidates[j]][idx100];
                    if (totalVal > bestVal) {
                        bestVal = totalVal;
                        bestIdx = j;
                    }
                }
            }
        }

        // 构造解
        vector<int> selected;
        if (selectCount > 0 && bestIdx != -1) {
            int k = selectCount;
            int idx = bestIdx;
            while (k > 0) {
                selected.push_back(allAvenues[candidates[idx]]);  // 转换为实际大道值
                idx = prev[k][idx];
                k--;
            }
            reverse(selected.begin(), selected.end());
        }
        
        // 添加固定边界
        vector<int> result;
        result.push_back(1);
        result.insert(result.end(), selected.begin(), selected.end());
        result.push_back(100);
        
        // 确保数量正确
        while (result.size() < a) {
            for (int i = 2; i < 100 && result.size() < a; i++) {
                if (find(result.begin(), result.end(), i) == result.end()) {
                    result.push_back(i);
                }
            }
        }
        
        sort(result.begin(), result.end());

        // 输出
        cout << a;
        for (int av : result) cout << " " << av;
        cout << endl;
    }
    return 0;
}