【华为OD-E卷 - 判断一组不等式是否满足约束并输出最大差 100分（python、java、c++、js、c）】
题目
给定一组不等式，判断是否成立并输出不等式的最大差(输出浮点数的整数部分)
要求:
不等式系数为 double类型，是一个二维数组 不等式的变量为 int类型，是一维数组; 不等式的目标值为 double类型，是一维数组 不等式约束为字符串数组，只能是:“>”,“>=”,“<”,“<=”,“=”， 例如，不等式组:
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，最大差
用例
用例一：
输入：
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;<=,<=,<=
输出：
false 458
用例二：
输入：
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;<=,>=,<=
输出：
false 758
python解法
- 解题思路：
- 输入处理：
输入是一行字符串，由分号 “;” 分隔的多个子串组成。
每个子串中，元素由逗号 “,” 分隔，需要进一步拆分。
数据解析：
a：前三行数据（3×5 矩阵），存储系数矩阵，转换为 float 类型。
x：第四行数据（长度为5），存储变量值，转换为 float 类型。
b：第五行数据（长度为3），存储约束的右侧数值，转换为 float 类型。
y：第六行数据（长度为3），存储约束类型（如 “>=”、“<=”` 等）。
约束验证：
判断 diff 是否满足 y[i] 约束。
结果计算：
valid 变量记录所有约束是否满足。
计算 max_diff（所有 diff 中的最大值，取 int 类型）。
输出格式化：
以小写格式输出 valid 和 max_diff。
使用到的算法
字符串处理：
split(“;”) 解析输入行，拆分为多个子字符串。
split(“,”) 进一步拆分每个子字符串。
map(float, arr[i]) 将字符串转换为浮点数。
矩阵运算：
sum(a[i][j] * x[j] for j in range(5)) 计算线性表达式的值。
条件判断：
satisfies_constraint(diff, y[i]) 判断 diff 是否符合 y[i] 约束。
最大值计算：
max(diffs) 找到 diffs 中的最大值，并转换为 int
# 读取输入并解析为嵌套列表
arr = list(map(lambda s: s.split(","), input().split(";")))
def satisfies_constraint(value, constraint):
"""
判断 value 是否满足约束 constraint
:param value: 计算得到的 diff 值
:param constraint: 约束条件（">", ">=", "<", "<=", "="）
:return: 满足约束返回 True，否则返回 False
"""
return (constraint == ">" and value > 0) or \
(constraint == ">=" and value >= 0) or \
(constraint == "<" and value < 0) or \
(constraint == "<=" and value <= 0) or \
(constraint == "=" and value == 0)
def getResult(arr):
"""
计算线性不等式的约束是否满足，并返回最大偏差值
:param arr: 解析后的输入数据
"""
# 提取 a（3×5 矩阵），x（长度 5），b（长度 3），y（约束条件）
a = [list(map(float, arr[i])) for i in range(3)] # 读取 3×5 系数矩阵
x = list(map(float, arr[3])) # 变量 x（长度 5）
b = list(map(float, arr[4])) # 约束右侧值（长度 3）
y = arr[5] # 约束符号（长度 3）
diffs = [] # 记录计算出的偏差值
valid = True # 是否满足所有约束
# 遍历每个不等式
for i in range(3):
# 计算 线性表达式 的值：Σ(a[i][j] * x[j]) - b[i]
diff = sum(a[i][j] * x[j] for j in range(5)) - b[i]
diffs.append(diff) # 记录偏差值
# 检查是否满足对应的约束
if not satisfies_constraint(diff, y[i]):
valid = False # 若不满足，标记 valid 为 False
# 计算最大偏差值，并转换为整数
max_diff = int(max(diffs))
# 输出结果，转换为小写格式
print(f"{valid} {max_diff}".lower())
# 调用函数计算结果
getResult(arr)
java解法
- 解题思路
- 输入处理：
从标准输入读取一行字符串，其中数据由 ; 分隔。
使用 split(“;”) 拆分成多个子数组，并进一步用 split(“,”) 解析每个子数组的具体值。
数据解析：
cf（系数矩阵）：前三个子数组，大小为 3×5，用于存储不等式左侧的系数。
var（变量值）：第四个子数组，长度 5，表示 x1,x2,x3,x4,x5 的值。
tgt（目标值）：第五个子数组，长度 3，用于存储不等式右侧的 b。
cs（约束类型）：第六个子数组，长度 3，存储不等式的符号，如 “>=”、“<=”` 等。
计算 diff 并判断约束：
计算 diff[i] = sum(a[i][j] * x[j]) - b[i]，即线性表达式的值与目标值 b[i] 之差。
通过 checkC(diff[i], cs[i]) 检查 diff[i] 是否符合 cs[i] 约束：
“>”：diff[i] > 0
“>=”：diff[i] >= 0
“<”：diff[i] < 0
“<=”：diff[i] <= 0
“=”：diff[i] == 0
如果某个 diff[i] 不符合约束，valid = false。
计算最大 diff 并输出：
记录 maxD = max(diff[i])（取整数）。
输出 valid 和 maxD。
使用到的算法
字符串处理：
split(“;”) 解析输入行，拆分为多个子字符串。
split(“,”) 进一步拆分子字符串，解析数值。
矩阵运算：
sum(a[i][j] * x[j]) 计算线性表达式。
条件判断：
switch 语句检查 diff[i] 是否满足 cs[i] 约束。
最大值计算：
Math.max(maxD, diff[i]) 找到 diff 数组中的最大值。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 读取输入，并按 ";" 拆分多个数据部分
String[][] ia = Arrays.stream(sc.nextLine().split(";"))
.map(s -> s.split(","))
.toArray(String[][]::new);
// 系数矩阵 cf（3×5）
double[][] cf = new double[3][5];
int idx = 0;
for (int i = 0; i < 3; i++) {
cf[i] = Arrays.stream(ia[idx++]).mapToDouble(Double::parseDouble).toArray();
}
// 变量值 var（长度 5）
double[] var = Arrays.stream(ia[idx++]).mapToDouble(Double::parseDouble).toArray();
// 目标值 tgt（长度 3）
double[] tgt = Arrays.stream(ia[idx++]).mapToDouble(Double::parseDouble).toArray();
// 约束条件 cs（长度 3）
String[] cs = ia[idx];
// 存储计算的 diff 值
double[] df = new double[3];
boolean valid = true; // 标记是否所有不等式均满足
double maxD = Double.NEGATIVE_INFINITY; // 记录最大 diff 值
// 计算每个不等式的 diff 并检查约束
for (int i = 0; i < 3; i++) {
df[i] = 0;
// 计算 Σ(a[i][j] * x[j])
for (int j = 0; j < 5; j++) {
df[i] += cf[i][j] * var[j];
}
// 计算 diff[i] = Σ(a[i][j] * x[j]) - b[i]
df[i] -= tgt[i];
// 记录最大 diff 值
maxD = Math.max(maxD, df[i]);
// 判断当前 diff[i] 是否满足约束
if (!checkC(df[i], cs[i])) {
valid = false;
}
}
// 输出最终结果：是否所有不等式均满足 + 最大 diff
System.out.println(valid + " " + (int) maxD);
}
/**
* 判断 diff 是否满足给定约束条件
* @param v diff 值
* @param c 约束符号（">", ">=", "<", "<=", "="）
* @return 满足约束返回 true，否则返回 false
*/
public static boolean checkC(double v, String c) {
switch (c) {
case ">":
return v > 0;
case ">=":
return v >= 0;
case "<":
return v < 0;
case "<=":
return v <= 0;
case "=":
return v == 0;
default:
return false;
}
}
}
C++解法
- 解题思路
更新中
C解法
更新中
JS解法
更新中
注意：
如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏