UVa 10373 The Brick Stops Here

原创于 2025-11-26 07:40:09 发布 · 917 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

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

动态规划专栏收录该内容

133 篇文章

订阅专栏

题目描述

你被一家黄铜砖工厂的几位客户雇佣。黄铜是铜和锌的合金；每块砖重 $1000$ 克，其中铜的含量可以在 $1$ 到 $999$ 克之间。工厂通过各种工艺生产不同类型的砖，每种类型的铜浓度和价格不同。

你的客户希望购买一定数量 $M$ 的砖，这些砖必须是不同类型的。它们将被熔化在一起，混合后的铜浓度必须在每千克 $CM in$ 到 $CM a x$ 克之间。他们的目标是选择 $M$ 种类型的砖，使得混合后的浓度符合要求，并且总价格最小。

输入格式

第一行：测试用例数量
每个测试用例：
- 第一行：砖类型数量 $N$ ( $\leq N \leq 200$ )
- 接下来 $N$ 行：每行包含铜浓度和价格（美分）
- 接下来一行：客户数量 $C$ ( $\leq C \leq 100$ )
- 接下来 $C$ 行：每行包含 $M$ , $CM in$ , $CM a x$ ( $\leq M \leq 20$ )

输出格式

对于每个客户，输出满足要求的最小价格，如果无法满足则输出 impossible。

题目分析

问题转化

每块砖重 $1000$ 克，铜含量为 $co n ce n t r a t i o n$ 克。当选择 $M$ 块砖时：

总铜量 = 所选砖的铜含量之和
总重量 = $\times 1000$ 克
平均浓度 = 总铜量 / $M$ （克/千克）

要求平均浓度在 $[CM in, CM a x]$ 范围内，等价于：

总铜量 $∈[M×CMin,M×CMax]\in [M \times CMin, M \times CMax]$

因此，问题转化为：从 $N$ 个物品中选择恰好 $M$ 个，使得它们的铜含量之和在 $[L, R]$ 范围内（其中 $\times CMin$ , $\times CMax$ ），并且总价格最小。

动态规划解法

这是一个典型的背包问题变种，我们需要考虑三个维度：

选择的砖块数量
铜含量总和
最小价格

状态定义

设 $d p [i] [j]$ 表示选择 $i$ 块砖，铜含量总和为 $j$ 的最小价格。

状态初始化

$d p [0] [0] = 0$ （选择 $0$ 块砖，铜含量为 $0$ 的价格为 $0$ ）
其他状态初始化为无穷大（表示不可达）

状态转移

对于每块砖（铜含量 $c$ ，价格 $p$ ），我们采用倒序更新的方式避免重复选择同一块砖：

for k = 0 to n-1:          // 遍历每块砖
    for i = m down to 1:   // 倒序遍历选择的砖块数量
        for j = high down to c:  // 倒序遍历铜含量总和
            if dp[i-1][j-c] != INF:
                dp[i][j] = min(dp[i][j], dp[i-1][j-c] + p)

答案提取

在所有满足 $\leq j \leq R$ 的 $d p [M] [j]$ 中找最小值。

复杂度分析

砖块类型数： $\leq 200$
最大选择数： $\leq 20$
铜含量最大和： $20 \times 999 \approx 20000$
时间复杂度： $\times M \times R)$ ，在题目约束下可行

代码实现

// The Brick Stops Here
// UVa ID: 10373
// Verdict: Accepted
// Submission Date: 2025-11-25
// UVa Run Time: 4.850s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

const int INF = 1e9;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        vector<int> copper(n), price(n);
        for (int i = 0; i < n; i++)
            cin >> copper[i] >> price[i];

        int clients;
        cin >> clients;
        while (clients--) {
            int m, cmin, cmax;
            cin >> m >> cmin >> cmax;
            int low = m * cmin;
            int high = m * cmax;

            vector<vector<int>> dp(m + 1, vector<int>(high + 1, INF));
            dp[0][0] = 0;

            for (int k = 0; k < n; k++) {
                for (int i = m; i >= 1; i--) {
                    for (int j = high; j >= copper[k]; j--) {
                        if (dp[i - 1][j - copper[k]] != INF)
                            dp[i][j] = min(dp[i][j], dp[i - 1][j - copper[k]] + price[k]);
                    }
                }
            }

            int ans = INF;
            for (int j = low; j <= high; j++)
                ans = min(ans, dp[m][j]);

            if (ans == INF) cout << "impossible" << endl;
            else cout << ans << endl;
        }
        if (t) cout << endl;
    }
    return 0;
}

优化实现：

// The Brick Stops Here
// UVa ID: 10373
// Verdict: Accepted
// Submission Date: 2025-11-25
// UVa Run Time: 2.200s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

const int INF = 1e9;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        vector<int> copper(n), price(n);
        for (int i = 0; i < n; i++)
            cin >> copper[i] >> price[i];
        
        int clients;
        cin >> clients;
        while (clients--) {
            int m, cmin, cmax;
            cin >> m >> cmin >> cmax;
            int low = m * cmin;
            int high = m * cmax;
            
            if (low > high) {
                cout << "impossible" << endl;
                continue;
            }

            // 优化：限制状态空间大小
            int maxSum = min(high, m * 999);
            vector<vector<int>> dp(m + 1, vector<int>(maxSum + 1, INF));
            dp[0][0] = 0;
            
            int bestPrice = INF;
            
            for (int k = 0; k < n; k++) {
                int c = copper[k];
                int p = price[k];
                
                // 价格剪枝：如果当前砖块价格已经超过已知最优解，跳过
                if (p >= bestPrice) continue;
                
                for (int i = m - 1; i >= 0; i--) {
                    for (int j = min(maxSum - c, (i + 1) * 999); j >= 0; j--) {
                        if (dp[i][j] != INF) {
                            int newSum = j + c;
                            int newPrice = dp[i][j] + p;
                            
                            // 价格剪枝
                            if (newPrice >= bestPrice) continue;
                            
                            if (newSum <= maxSum) {
                                dp[i + 1][newSum] = min(dp[i + 1][newSum], newPrice);
                                
                                // 如果找到完整解，更新最优解
                                if (i + 1 == m && newSum >= low) {
                                    bestPrice = min(bestPrice, newPrice);
                                }
                            }
                        }
                    }
                }
            }
            
            // 最终检查
            for (int j = low; j <= maxSum; j++) {
                if (dp[m][j] != INF) {
                    bestPrice = min(bestPrice, dp[m][j]);
                }
            }

            if (bestPrice == INF) cout << "impossible" << endl;
            else cout << bestPrice << endl;
        }
        if (t) cout << endl;
    }
    return 0;
}