华为OD机试_2025 B卷_判断一组不等式是否满足约束并输出最大差（Python，100分）（附详细解题思路）

题目描述

给定一组不等式，判断是否成立并输出不等式的最大差(输出浮点数的整数部分)
要求:

1. 不等式系数为 double类型，是一个二维数组
2. 不等式的变量为 int类型，是一维数组;
3. 不等式的目标值为 double类型，是一维数组
4. 不等式约束为字符串数组，只能是:“>”,“>=”,“<”,“<=”,“=”，
   例如，不等式组:
   a11x1+a12x2+a13x3+a14x4+a15x5<=b1;
   a21x1+a22x2+a23x3+a24x4+a25x5<=b2;
   a31x1+a32x2+a33x3+a34x4+a35x5<=b3;
   最大差 = max{(a11x1+a12x2+a13x3+a14x4+a15x5-b1),(a21x1+a22x2+a23x3+a24x4+ a25x5-b2),(a31x1+a32x2+a33x3+a34x4+a35x5-b3)},
   类型为整数(输出浮点数的整数部分)

输入描述
a11,a12,a13,a14,a15,a21,a22,a23,a24,a25, a31,a32,a33,a34,a35,x1,x2,x3,x4,x5,b1,b2,b3,<=,<=,<=
1)不等式组系数(double类型):
a11,a12,a13,a14,a15
a21,a22,a23,a24,a25
a31,a32,a33,a34,a35
2)不等式变量(int类型):x1,x2,x3,x4,x5
3)不等式目标值(double类型):b1,b2,b3
4)不等式约束(字符串类型):<=,<=,<=

输出描述
true或者 false，最大差

用例

不等式组验证与最大差计算算法详解

核心解题思路

本题目要求验证给定的不等式组是否成立，并计算不等式组的最大差值。核心解题思路可分为三个步骤：

关键步骤

1. 数据解析：将输入字符串解析为系数矩阵、变量数组、目标值和约束条件
2. 不等式验证：计算每个不等式的左边值，验证是否满足约束条件
3. 最大差计算：计算所有不等式左边值与目标值的差值，找出最大值

核心算法

• 点积计算：使用系数矩阵的行与变量数组计算每个不等式的左边值
• 约束验证：根据约束符号(>, >=, <, <=, =)验证不等式
• 差值分析：计算每个不等式的差值(左边值 - 目标值)，找出最大值

完整代码实现

def main():
    # 读取输入
    data = input().strip()
    
    # 分割输入字符串
    parts = data.split(';')
    k = len(parts) - 3  # 不等式个数
    
    # 解析系数矩阵
    coeffs = []
    for i in range(k):
        row = [float(x) for x in parts[i].split(',')]
        coeffs.append(row)
    
    # 解析变量数组
    variables = [int(x) for x in parts[k].split(',')]
    
    # 解析目标值
    targets = [float(x) for x in parts[k+1].split(',')]
    
    # 解析约束条件
    constraints = [x.strip() for x in parts[k+2].split(',')]
    
    # 初始化结果
    all_valid = True
    max_diff = -10**18  # 初始化为极小值
    
    # 处理每个不等式
    for i in range(k):
        # 计算左边值 (系数与变量的点积)
        left_value = 0.0
        for j in range(len(variables)):
            left_value += coeffs[i][j] * variables[j]
        
        # 计算差值
        diff = left_value - targets[i]
        
        # 更新最大差值
        if diff > max_diff:
            max_diff = diff
        
        # 验证约束条件
        constraint = constraints[i]
        if constraint == '<=':
            if left_value > targets[i]:
                all_valid = False
        elif constraint == '<':
            if left_value >= targets[i]:
                all_valid = False
        elif constraint == '>=':
            if left_value < targets[i]:
                all_valid = False
        elif constraint == '>':
            if left_value <= targets[i]:
                all_valid = False
        elif constraint == '=':
            if abs(left_value - targets[i]) > 1e-10:  # 考虑浮点数精度
                all_valid = False
    
    # 输出结果
    result = "true" if all_valid else "false"
    print(f"{result} {int(max_diff)}")

if __name__ == "__main__":
    main()

算法原理解析

1. 数据解析模块

parts = data.split(';')
k = len(parts) - 3

• 输入格式：输入字符串分为四部分（系数矩阵、变量、目标值、约束）
• 系数矩阵：前k部分为不等式系数，每行逗号分隔
• 变量数组：第k部分为整型变量
• 目标值：第k+1部分为双精度目标值
• 约束条件：第k+2部分为字符串约束

2. 点积计算

left_value = 0.0
for j in range(len(variables)):
    left_value += coeffs[i][j] * variables[j]

• 数学表示：$left\_value={\sum }_{j=0}^{n-1}coeff[i][j]\times variables[j]$
• 时间复杂度：O(k×n)，k为不等式数，n为变量数

3. 约束验证

if constraint == '<=':
    if left_value > targets[i]:
        all_valid = False
elif constraint == '<':
    # ...其他约束类似

• 约束类型：支持5种比较操作符
• 浮点精度处理：对等号约束使用容差1e-10

4. 最大差计算

diff = left_value - targets[i]
if diff > max_diff:
    max_diff = diff

• 差值定义：左边值 - 目标值
• 整数转换：使用int()获取整数部分（截断小数）

示例解析

示例1：输入2.3,3,5.6,7,6;11,3,8.6,25,1;0.3,9,5.3,66,7.8;1,3,2,7,5;340,670,80.6;<=,<=,<=

1. 数据解析：

   • 系数矩阵：

     [ [2.3, 3, 5.6, 7, 6],
       [11, 3, 8.6, 25, 1],
       [0.3, 9, 5.3, 66, 7.8] ]
     

   • 变量：[1, 3, 2, 7, 5]
   • 目标值：[340, 670, 80.6]
   • 约束：['<=', '<=', '<=']

2. 不等式计算：

   • 不等式1：2.3*1 + 3*3 + 5.6*2 + 7*7 + 6*5 = 101.5 → 101.5 <= 340 (成立)
   • 不等式2：11*1 + 3*3 + 8.6*2 + 25*7 + 1*5 = 217.2 → 217.2 <= 670 (成立)
   • 不等式3：0.3*1 + 9*3 + 5.3*2 + 66*7 + 7.8*5 = 538.9 → 538.9 <= 80.6 (不成立)

3. 最大差计算：

   • 差值：101.5-340 = -238.5, 217.2-670 = -452.8, 538.9-80.6 = 458.3
   • 最大值：458.3 → 整数部分458

4. 输出：false 458

示例2：输入2.36,3,6,7.1,6;1,30,8.6,2.5,21;0.3,69,5.3,6.6,7.8;1,13,2,17,5;340,67,300.6;<=,>=,<=

1. 数据解析：

   • 系数矩阵：

     [ [2.36, 3, 6, 7.1, 6],
       [1, 30, 8.6, 2.5, 21],
       [0.3, 69, 5.3, 6.6, 7.8] ]
     

   • 变量：[1, 13, 2, 17, 5]
   • 目标值：[340, 67, 300.6]
   • 约束：['<=', '>=', '<=']

2. 不等式计算：

   • 不等式1：2.36*1 + 3*13 + 6*2 + 7.1*17 + 6*5 = 204.06 → 204.06 <= 340 (成立)
   • 不等式2：1*1 + 30*13 + 8.6*2 + 2.5*17 + 21*5 = 555.7 → 555.7 >= 67 (成立)
   • 不等式3：0.3*1 + 69*13 + 5.3*2 + 6.6*17 + 7.8*5 = 1059.1 → 1059.1 <= 300.6 (不成立)

3. 最大差计算：

   • 差值：204.06-340 = -135.94, 555.7-67=488.7, 1059.1-300.6=758.5
   • 最大值：758.5 → 整数部分758

4. 输出：false 758

边界情况测试

测试1：所有不等式成立

输入: "1,1;2,2;1,1;3;=,="
解析: 
  系数: [[1,1], [2,2]]
  变量: [1,1]
  目标值: [3, 3]
  约束: ["=", "="]
计算:
  不等式1: 1*1+1*1=2 ≠ 3 → 不成立
  不等式2: 2*1+2*1=4 ≠ 3 → 不成立
输出: false 1 (4-3=1)

测试2：浮点数精度问题

输入: "0.1,0.2;0.1,0.2;1,1;0.3;="
解析:
  系数: [[0.1,0.2]]
  变量: [1,1]
  目标值: [0.3]
  约束: ["="]
计算:
  左边值: 0.1*1+0.2*1=0.3
  浮点精度处理: abs(0.3-0.3)<1e-10 → 成立
输出: true 0

测试3：负差值

输入: "2,3;1,1;5,5;10;<"
解析:
  系数: [[2,3]]
  变量: [1,1]
  目标值: [10]
  约束: ["<"]
计算:
  左边值: 2*1+3*1=5 < 10 → 成立
  差值: 5-10=-5
输出: true -5

总结与扩展

关键知识点

1. 字符串处理：复杂输入格式的解析技巧
2. 矩阵运算：点积计算的核心算法
3. 约束验证：多种比较操作的统一处理
4. 浮点精度：等值比较的容差处理

实际应用场景

1. 数学建模：验证复杂不等式组的可行性
2. 金融分析：评估投资组合约束条件
3. 工程优化：验证设计参数是否满足约束
4. 质量控制：检查产品参数是否符合标准

扩展思考

核心启示：通过系统化的输入解析、精确的数学计算和全面的约束验证，本算法高效解决了不等式组的验证和差值计算问题。清晰的模块划分和边界处理保证了算法的健壮性。

初学者可从中学习：

1. 复杂输入数据的解析方法
2. 矩阵与向量运算的实现
3. 多种约束条件的统一处理
4. 浮点数比较的精度控制
5. 算法结果的综合分析与输出