Gurobi：应对复杂问题的数学优化

当变量规模上来时，基础求解器和试错法就会力不从心。Gurobi 能以速度和精度驾驭这些复杂性，将原本可能需要数小时的问题在几秒内解决。这就是“希望有个可行方案”和“通过数学证明您拥有最优方案”之间的差别。

本教程将带您上手这款功能强大的商业求解器 Gurobi。我会演示如何安装 Python 库、构建第一个模型，并扩展到如混合整数规划等高级问题。

理解数学优化及 Gurobi 的作用

在动手写代码之前，先弄清“优化”真正意味着什么，会帮助您判断何时应当使用 Gurobi 而不是标准编程方法。

什么是数学优化？

数学优化是在所有可能解中找出最优解。您定义“最优”的含义（最小成本、最大利润、最短时间）、可控内容（决策变量）以及所受限制（约束）。优化器会在可行解空间中搜索并找到最优解。

这不同于传统编程，传统编程需要您明确步骤。优化建模是用数学刻画问题，再交由求解器决定如何求解。您并不是写“如果这样就那样”的逻辑，而是定义变量关系，让算法寻找最佳取值。

Gurobi 在优化中的重要性

为何 Gurobi 脱颖而出

Gurobi 一直位列速度最快的商业优化器之一。基准测试常显示，其在大规模问题上显著优于开源替代品。对于需要按小时运行优化或必须在严格时限内出结果的场景，速度至关重要。

行业采用

物流、金融、能源、医疗等行业的生产系统广泛使用 Gurobi。FedEx 用它优化配送路线，金融机构用它做数十亿美元的资产配置。能源公司用它编制发电计划。这些并非学术练习，而是处理真金白银与真实约束的系统。

求解器能力

Gurobi 支持线性规划（LP）、混合整数规划（MIP）、二次规划（QP）等。它内置最前沿算法，如并发优化：并行运行多种方法，取最快者。无需手动挑算法，兼得可靠与高效。

Gurobi 的安装与配置

安装 Gurobi 只需几步。配置完成后，它可与Python无缝协作。

安装与设置

下载与安装

前往 Gurobi 官网 下载与您的操作系统匹配的安装包，内含优化器、gurobipy 接口以及文档。除非需要自定义路径，安装时建议采用默认设置。

安装完成后，验证是否成功：

import gurobipy as gp
print(f"Gurobi version: {gp.__version__}")技术支持

此处通过打印版本号来验证安装。成功输出即表示环境就绪。

许可选项

除小型测试外，Gurobi 需要许可证。可选方案：

• 免费试用许可证：30 天评估期。使用工作邮箱在 Gurobi 官网申请。
• 学术许可证：高校师生免费。用学术邮箱验证即可不限量使用，非常适合学习。
• 商用许可证：用于业务。价格随规模而变。命名用户许可适合个人数据科学家，浮动许可支持团队共享算力。
• 云许可：按用量付费。无需预付，仅为实际使用买单。适合偶发的优化任务。

我学习用学术许可证，生产用商业许可证。试用期足够让您在决策前深入体验。

环境配置

Python 设置

Gurobi 兼容 Python 3.7+。建议使用虚拟环境避免依赖冲突：

python -m venv gurobi_env
gurobi_env\Scripts\activate
source gurobi_env/bin/activate
pip install gurobipy技术支持

这些命令会创建干净的工作区并安装所需库。

Jupyter Notebook 集成

用于交互式开发，notebook 与 Gurobi 十分契合：

pip install jupyter
jupyter notebook
import gurobipy as gp
print("Gurobi ready!")技术支持

这段代码安装 Jupyter、启动服务，并快速检查 Gurobi 能否在 notebook 中正确加载。

何时不该用 Gurobi

Gurobi 功能强大，但并非总是最佳选择。

• 简单问题：若变量约 50 个且仅含基本线性约束，免费求解器如 scipy.optimize.linprog 或 Excel 求解器 足够胜任。

• 成本：商业许可证价格不菲。对于非关键的内部工具，CBC 或 GLPK（通过 PuLP）等开源方案或许已足够。

• 启发式：若需在毫秒级获得“足够好”的结果（如实时博弈），遗传算法等启发式往往优于精确求解器。

当问题规模很大（1 万个以上变量）或需要二次约束等高级特性时，请使用 Gurobi。

平台兼容性

Gurobi 支持 Windows、macOS 与 Linux。AWS、Azure、Google Cloud 等云环境也可通过其商城使用 Gurobi。我已在三大云平台上部署过 Gurobi 模型，未遇到平台相关问题。

构建优化模型

安装完成后，我们来构建您的第一个模型。以下核心概念适用于您将要解决的每个问题。

优化模型的关键组成

每个模型都有三大要素：

决策变量

即优化器需要做出的选择。在生产计划中，可能是“产品 A 产量”“产品 B 产量”。您定义变量，Gurobi 赋值。

目标函数

即您的目标，是要最大化还是最小化。例如最大化利润（3*product_a + 5*product_b）或最小化成本。每个模型只有一个目标。

约束

即您所面对的限制。不能超过工厂产能，不能超出预算。约束决定了哪些解是可行的。

建模最佳实践

使用清晰的变量名。不要用 x[1]，而要用 produce_product_a。这能在调试时省下大量时间，我会在故障排查部分解释。

尽量让约束简单。把复杂逻辑拆分为更小、更简单的约束，有助于阅读与调试。

现代 Gurobi：矩阵 API

如果您有数据科学背景，基于循环的建模可能会感觉很慢。Gurobi 13.0+ 提供了使用 NumPy 数组的矩阵 API，使建模速度提升 10–50 倍。

下面是用向量方式编写的烘焙店模型：

import gurobipy as gp
import numpy as np

# Data
prices = np.array([2.0, 5.0])
resources = np.array([[0.5, 2.0], [1.0, 1.0]])
limits = np.array([100.0, 80.0])

model = gp.Model("bakery_matrix")
x = model.addMVar(shape=2, name="x")

model.setObjective(prices @ x, gp.GRB.MAXIMIZE)
model.addConstr(resources @ x <= limits, name="constraints")

model.optimize()技术支持

这种 A @ x <= b 语法更简洁，也更适合生产系统。

创建一个简单的线性规划模型

我们来解决一个实用问题：一家烘焙店决定要烤多少面包和蛋糕以最大化利润。

问题设定：

- 面包利润：$2｜面粉：0.5 kg

- 蛋糕利润：$5｜面粉：2 kg

- 可用面粉：100 kg

- 烤箱产能：80 件

模型如下：

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("bakery_optimization")

bread = model.addVar(name="bread", vtype=GRB.CONTINUOUS, lb=0)
cake = model.addVar(name="cake", vtype=GRB.CONTINUOUS, lb=0)

model.setObjective(2 * bread + 5 * cake, GRB.MAXIMIZE)

model.addConstr(0.5 * bread + 2 * cake <= 100, name="flour_limit")
model.addConstr(bread + cake <= 80, name="oven_capacity")

model.optimize()

if model.status == GRB.OPTIMAL:
    print(f"Optimal profit: ${model.objVal:.2f}")
    print(f"Bake {bread.X:.2f} loaves of bread")
    print(f"Bake {cake.X:.2f} cakes")
else:
    print("No optimal solution found")技术支持

该代码初始化模型、定义变量并设定利润最大化目标。随后应用上述约束并求解最优生产计划。

理解求解日志

当您运行 model.optimize() 时，Gurobi 会打印日志。阅读方式如下：

Gurobi Optimizer version 13.0.0...
Presolve removed 0 rows and 0 columns
...
Explored 0 nodes (2 simplex iterations) in 0.01 seconds
Optimal objective  2.800000000e+02技术支持

• 预求解（Presolve）：Gurobi 会在求解前简化问题。“移除了行”表示找到冗余约束。
• 单纯形迭代次数：算法的步数。小问题却出现很高迭代数，可能说明建模存在问题。
• 最优目标值：最终结果（例如 $280 利润）。
• Gap：对整数问题，显示当前最优可行解与理论最优之间的差距。

关注日志能帮助您判断模型是在“卡住”还是在“努力计算”。

以上概念可直接扩展。不论变量是 10 个还是 1 万个，模式都相同。

Gurobi 支持的高级问题类型

线性规划只是起点。Gurobi 能处理更复杂的类型，贴近现实细节，包括 13.0 版本中的非凸 MINLP 新能力。

混合整数线性规划

有何不同

混合整数规划（MIP）允许变量为整数。比如您不可能建 0.7 座工厂，因此需要整数解。

真实应用

设施选址：在城市 A 建仓库？是（1）或否（0）。

生产排程：批量大小通常必须为整数。

网络设计：路径选择通常是二元决策。流量要么经过该链路，要么不经过。

示例：设施选址

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("facility_location")

cities = ['CityA', 'CityB', 'CityC']
fixed_costs = {'CityA': 10000, 'CityB': 8000, 'CityC': 12000}

open_warehouse = model.addVars(cities, vtype=GRB.BINARY, name="open")

model.setObjective(
    gp.quicksum(fixed_costs[city] * open_warehouse[city] for city in cities),
    GRB.MINIMIZE
)

model.addConstr(gp.quicksum(open_warehouse[city] for city in cities) >= 2)

model.optimize()

print("Open warehouses in:")
for city in cities:
    if open_warehouse[city].X > 0.5:
        print(f"  {city}")技术支持

这里用二元变量决定是否开仓。模型在确保至少两处设施开启的同时，最小化固定成本。

二次与非线性规划

二次规划（QP）

当目标函数包含平方项或变量乘积时，就是 QP。投资组合优化是经典示例，因为风险（方差）是二次的。

二次约束规划（QCP）

约束也可以是二次的。可类比涉及圆或曲线边界的问题。

示例：投资组合优化

import gurobipy as gp
from gurobipy import GRB
import numpy as np

model = gp.Model("portfolio")

assets = ['StockA', 'StockB', 'StockC']
expected_returns = [0.12, 0.18, 0.10]

covariance = np.array([
    [0.04, 0.01, 0.02],
    [0.01, 0.09, 0.03],
    [0.02, 0.03, 0.05]
])

weights = model.addVars(len(assets), name="weight", lb=0, ub=1)

model.setObjective(
    gp.quicksum(expected_returns[i] * weights[i] for i in range(len(assets))),
    GRB.MAXIMIZE
)

model.addConstr(gp.quicksum(weights[i] for i in range(len(assets))) == 1)

risk_expr = gp.quicksum(
    covariance[i][j] * weights[i] * weights[j]
    for i in range(len(assets))
    for j in range(len(assets))
)
model.addConstr(risk_expr <= 0.05, name="risk_limit")

model.optimize()

print("Optimal portfolio allocation:")
for i, asset in enumerate(assets):
    print(f"{asset}: {weights[i].X * 100:.1f}%")技术支持

该设置用于投资组合优化。在最大化收益的同时，通过二次约束严格限制总风险（方差）。

其他支持的问题类型

二阶锥规划（SOCP）

涉及几何约束（如圆锥或圆形边界）的问题属于此类，常见于鲁棒优化和工程设计。

混合整数二次规划（MIQP）

将整数变量与二次目标或约束结合。适用于具有非线性关系的离散优化。

Gurobi 对以上类型均有原生支持。您无需为适配特定求解器而重写问题，Gurobi 会自动识别问题类型并应用合适算法。

Gurobi 支持的优化问题类型。作者自制图片。

Gurobi 算法及其应用

算法选择

Gurobi 会自动选择算法，但了解选项有助于在求解缓慢时进行排障。

Method 取值：

• -1 （默认）：让 Gurobi 决定

• 0：原始单纯形（多数 LP 表现良好）

• 1：对偶单纯形（从不可行起步时更佳）

• 2：屏障法（超大模型或 QP 最优）

• 3：并发（多方法并行，择其快者）

• 4：确定性并发

• 5：确定性并发单纯形

• PDHG（一阶方法）：Gurobi 13.0 还包含 PDHG，这是一种基于梯度的方法，适合在 GPU 上处理海量 LP。

可通过求解日志查看实际采用了何种方法（例如“Barrier solved model...”）。

何时手动覆盖：若默认设置耗时过长，大模型可尝试屏障法，不确定性高的问题可尝试并发。

model.Params.Method = 2
model.Params.BarConvTol = 1e-8技术支持

这将显式选择屏障法并收紧收敛容差，适用于超大或敏感数据集。

利用 Gurobi 的高级功能

在掌握基础后，Gurobi 还提供企业级问题的强大工具。

分布式优化

对于单机耗时过久的超大模型，您可以拆分任务。Gurobi 的分布式优化可用多台机器共同求解同一问题，从而更快完成。

您可指定一台机器为“管理者”，其他为“工作者”。管理者把搜索树的部分分派给工作者并行求解。对小模型来说这有些小题大做，但对全球供应链或航班排程问题则至关重要。

多目标优化

现实很少只有一个目标。您可能既想最大化利润，又想最小化环境影响。

Gurobi 通过优先级来处理。您可以告诉它“先最大化利润，再在不降低利润超过 10% 的前提下最小化浪费”。或者用加权法：Objective = 0.7 * Profit - 0.3 * Waste。

# Multi-objective example
model.setObjectiveN(profit_expr, index=0, priority=2, name="Profit")
model.setObjectiveN(waste_expr, index=1, priority=1, name="Waste")技术支持

实时交互与回调

有时您会希望在 Gurobi 求解过程中进行干预。回调允许您在特定时点运行自定义代码，例如每次找到新解时。

我会用回调在解“足够好”时提前停止，或注入适合我数据的自定义启发式。

云端能力

本地笔记本适合开发，但生产通常需要更强算力。Gurobi Cloud 允许您把重负载转移到 AWS、Azure 或 Gurobi 自家的 Instant Cloud。按求解时间计费，非常适合偶发的重型工作负载。

实用建模最佳实践

写出高效模型需要策略。以下建议能让代码更简洁、更快速。

模型构建策略

从简单开始，逐步加复杂度

第一天别上来就写 50 条约束。先实现核心逻辑、验证，再逐步细化。我曾花大量时间调一个复杂模型，结果发现问题出在最基础的设置上。

使用有意义的变量与约束命名

x1 = model.addVar(name="x1")
model.addConstr(x1 + x2 <= 100, name="c1")

units_produced = model.addVar(name="units_produced")
model.addConstr(
    units_produced + units_stored <= warehouse_capacity,
    name="warehouse_capacity_limit"
)技术支持

注意差异：第二段能清楚描述业务逻辑。正如前文所说，这能节省调试成本。

预处理数据

在建模前校验数据。检查缺失值或不可能满足的约束。等 3 小时求解后才发现数据错误会非常痛苦。

合理缩放数据

Gurobi 能较好处理数值精度，但极端数值会带来麻烦。若成本以百万计、数量却以千分之一计，请把它们缩放到相近量级：

# 不要用 cost = 10000000 和 quantity = 0.0001
# 缩放为 cost = 10（单位：百万），quantity = 100（单位：1/1000）技术支持

良好缩放的模型很少发生数值问题，糟糕缩放的模型则常见。

数值稳定性注意事项

Gurobi 使用浮点数运算，并非无限精度。若您的约束是 x <= 1000000000，而容差为 1e-6，可能会出现怪异结果。

避免“Big M”约束，例如 if y=0 then x <= 1,000,000,000。应选择尽可能小的有效上界（如市场总量）。更紧的边界意味着更快、更稳定的求解。

热启动与模型修改

同一个问题很少只解一次。通常会有新数据到来（例如更新的需求）。

与其每次重建模型，不如使用热启动。把前一日的解作为起点传给 Gurobi。由于昨日最优方案往往接近今日，Gurobi 可跳过大量搜索工作。

# Warm start example
bread.Start = 40  # 从假设烤 40 个面包开始搜索技术支持

编程接口与集成

Gurobi 的 Python API

我们之所以使用 gurobipy，是因为它更 Pythonic。它支持运算符重载（如 x + y <= 5），并能与 pandas、NumPy 无缝集成。对于数据科学，这是使用 Gurobi 的最流行方式。

与其他语言的集成

生产系统常用 C++、Java 或 .NET 以提升速度。Gurobi 均提供支持。概念（变量、约束、目标）完全一致，仅语法不同。

在跨语言流程中，我常用 Python 快速原型（编码快），再用 C++ 部署（执行快），通过 Gurobi 的文件格式（.mps 或 .lp）在二者之间传递模型。

建模语言支持

Gurobi 也可接入 AMPL、GAMS 等专用建模语言，甚至 Excel。

- AMPL/GAMS： 适合不想写软件代码、专注数学的研究人员。

- Excel： 适合快速原型，或让业务方无需安装 Python 即可上手的演示。

性能优化与调优

调优流程

不要盲目调参。请遵循以下流程：

1. 测量基线：使用默认参数运行，记录求解时间。

2. 先设硬性上限：生产系统需要 TimeLimit。

3. 以精度换速度：仅在业务可接受时放宽 MIPGap。

4. 测试线程扩展：线程越多 ≠ 越快（4–8 线程后收益递减）。

# Example: Production deployment
model.Params.TimeLimit = 300  # API 响应的 5 分钟硬性上限
baseline_time = model.Runtime

if baseline_time > 240:  # 接近时限
    model.Params.MIPGap = 0.02  # 接受 2% 次优
    # 商业理由：2% 成本增加 < 延迟交付的罚金技术支持

性能基准

基准测试显示，Gurobi 在困难的 MIP 问题上常以数量级优势领先于开源求解器。虽然 scipy 处理小型 LP 没问题，但复杂性上来后，Gurobi 更显优势。您可在 Hans Mittelmann 的网站上找到独立的求解器性能对比。

调试与故障排查

模型不可行

当 Gurobi 报告“模型不可行”时，说明约束间存在冲突，无法同时满足所有约束。

找出冲突约束：

model.computeIIS()
model.write("infeasible.ilp")

print("Conflicting constraints:")
for c in model.getConstrs():
    if c.IISConstr:
        print(f"  {c.ConstrName}: {c.ConstrExpr}")技术支持

这会计算最小不可行子系统（IIS），精确指出互相冲突的约束。

无界模型

无界表示目标可以无限改进，通常意味着缺少约束。

检查：

- 是否为所有变量设定了边界？addVar(lb=0, ub=1000)

- 约束是否正确构建？

- 目标函数是否正确？

使用求解日志

启用详细日志，了解 Gurobi 在做什么：

model.Params.OutputFlag = 1
model.Params.LogToConsole = 1
model.Params.LogFile = "gurobi.log"技术支持

这会打开详细输出并保存到本地文件，便于回溯求解过程。

数据处理

在真实应用中，数据来自文件，而非硬编码列表。

import pandas as pd

# Load data
df = pd.read_csv("facility_costs.csv")
fixed_costs = dict(zip(df['city'], df['fixed_cost']))

# Validate BEFORE modeling
if any(c < 0 for c in fixed_costs.values()):
    raise ValueError("Costs cannot be negative")技术支持

“加载—校验—建模”的模式能避免静默错误。

Gurobi 的真实行业应用

理论固然重要，但更关键的是看看行业如何实际使用它。

供应链优化

分销网络设计

FedEx、UPS、Amazon 等会用Python 供应链分析课程中的理念，在满足交付承诺的同时最小化成本。

本示例将使用矩阵 API 高效处理规模问题。

import gurobipy as gp
from gurobipy import GRB
import numpy as np

# 1. Data Generation
factories = ["F1", "F2"]
warehouses = ["W1", "W2", "W3"]
customers = ["C1", "C2", "C3", "C4"]

# Cost matrices (Factory->Warehouse, Warehouse->Customer)
transport_fw = np.array([[2.0, 4.0, 5.0], [3.0, 1.0, 6.0]])
transport_wc = np.array([
    [1.5, 2.0, 3.0, 4.0],
    [3.0, 1.0, 2.0, 2.5],
    [5.0, 4.0, 1.0, 1.5]
])

# Capacity and Demand
factory_cap = np.array([1000, 1000])
demand = np.array([300, 500, 400, 600])

try:
    with gp.Model("SupplyChain_Matrix") as model:
        # 2. Variables (Matrix Form)
        # Flow F->W and W->C
        flow_fw = model.addMVar((len(factories), len(warehouses)), name="fw")
        flow_wc = model.addMVar((len(warehouses), len(customers)), name="wc")
        
        # Binary decision: Open warehouse?
        open_w = model.addMVar(len(warehouses), vtype=GRB.BINARY, name="open")

        # 3. Objective: Minimize Transport + Fixed Costs
        fixed_cost = 5000
        obj = (transport_fw * flow_fw).sum() + \
              (transport_wc * flow_wc).sum() + \
              (fixed_cost * open_w).sum()
        model.setObjective(obj, GRB.MINIMIZE)

        # 4. Constraints
        # Factory capacity (sum rows of flow_fw <= cap)
        model.addConstr(flow_fw.sum(axis=1) <= factory_cap, name="Cap")

        # Customer demand (sum cols of flow_wc >= demand)
        model.addConstr(flow_wc.sum(axis=0) >= demand, name="Demand")

        # Flow balance: Inflow to W == Outflow from W
        model.addConstr(flow_fw.sum(axis=0) == flow_wc.sum(axis=1), name="Balance")

        # Warehouse capacity linking: Flow out <= BigM * OpenBinary
        model.addConstr(flow_wc.sum(axis=1) <= 2000 * open_w, name="Link")

        model.optimize()

        if model.Status == GRB.OPTIMAL:
            print(f"Optimal Cost: ${model.ObjVal:,.2f}")
            print(f"Open Warehouses: {open_w.X}")

except gp.GurobiError as e:
    print(f"Error: {e}")技术支持

这种向量化方法（addMVar、sum(axis=1)）可瞬间处理数千变量，避免 Python 循环带来的迟缓。

供应链网络图。作者自制图片。

库存优化

在订购、持有与缺货成本间取得平衡并不容易。需求不确定时，这会变为随机优化，Gurobi 可通过情景建模来处理。

人员排班

排班计划

医院与呼叫中心需要在满足编制、劳动法规与偏好的前提下安排员工排班。

这是一类纯粹的混合整数问题。每项分配都是二元选择。若一家医院有 100 名护士与 50 个班次，就要权衡 5,000 个变量。

示例：护士排班

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("nurse_scheduling")

nurses = ['Alice', 'Bob', 'Carol', 'Dave']
shifts = ['Mon_Day', 'Mon_Night', 'Tue_Day', 'Tue_Night']
min_required = {'Mon_Day': 2, 'Mon_Night': 1, 'Tue_Day': 2, 'Tue_Night': 1}

schedule = model.addVars(nurses, shifts, vtype=GRB.BINARY, name="schedule")

model.setObjective(
    gp.quicksum(schedule[n, s] for n in nurses for s in shifts),
    GRB.MINIMIZE
)

for shift in shifts:
    model.addConstr(
        gp.quicksum(schedule[n, shift] for n in nurses) >= min_required[shift],
        name=f"min_staff_{shift}"
    )

for nurse in nurses:
    model.addConstr(
        gp.quicksum(schedule[nurse, s] for s in shifts) <= 3,
        name=f"max_shifts_{nurse}"
    )

for nurse in nurses:
    # Labor rule: 8-hour rest required between shifts
    model.addConstr(
        schedule[nurse, 'Mon_Day'] + schedule[nurse, 'Mon_Night'] <= 1,
        name=f"no_double_{nurse}_Mon"
    )
    model.addConstr(
        schedule[nurse, 'Tue_Day'] + schedule[nurse, 'Tue_Night'] <= 1,
        name=f"no_double_{nurse}_Tue"
    )

model.optimize()

print("Optimal schedule:")
for nurse in nurses:
    assigned = [s for s in shifts if schedule[nurse, s].X > 0.5]
    print(f"{nurse}: {', '.join(assigned)}")技术支持

该模型用二元变量刻画排班问题。它在满足编制、人力上限与强制休息的前提下，最小化总排班数。

金融投资组合优化

风险—收益权衡

组合优化要在预期收益与风险之间平衡。经典的 Markowitz 模型：

• 最大化：预期收益
• 满足：风险（方差）低于阈值
• 约束：预算、分散化要求、监管限制

这属于二次规划。收益对权重是线性的，而方差是二次的（涉及权重的乘积）。

实践考虑

真实的组合优化还包括：

• 交易成本（买卖会产生费用）
• 整数约束（部分资产不能买入零碎股）
• 监管要求（单一证券占比不得超过 10%）
• 再平衡约束（不应剧烈改变现有持仓）

资管机构每天都在运行这些优化，管理着数十亿资金。模型的求解时间会直接影响交易执行。

结语

我们覆盖了从安装 Gurobi 到构建复杂供应链模型的诸多内容。

现在，您无需在会议室里争论观点，直接把代码放到屏幕上：“这是数学上最优的方案”。讨论的方式就此改变。您不再猜测，而是给出证明。

去把它用在您下一个棘手问题上吧——那个您一直回避的排班冲突或预算挤压。也许完美答案一直就藏在您的数据里。

若您想进一步精进优化技能，请查看我们的 线性规划入门教程和 Python 优化入门课程，持续进阶。