一、导入数据

1.直接赋值

2.读取 Excel 文件

3.代码示例

import pandas as pd# 读取数据文件def readDataFile(readPath):  # readPath: 数据文件的地址和文件名    try:        if (readPath[-4:] == ".csv"):            dfFile = pd.read_csv(readPath, header=0, sep=",")  # 间隔符为逗号，首行为标题行            # dfFile = pd.read_csv(filePath, header=None, sep=",")  # sep: 间隔符，无标题行        elif (readPath[-4:] == ".xls") or (readPath[-5:] == ".xlsx"):  # sheet_name 默认为 0            dfFile = pd.read_excel(readPath, header=0)  # 首行为标题行            # dfFile = pd.read_excel(filePath, header=None)  # 无标题行        elif (readPath[-4:] == ".dat"):  # sep: 间隔符，header：首行是否为标题行            dfFile = pd.read_table(readPath, sep=" ", header=0)  # 间隔符为空格，首行为标题行            # dfFile = pd.read_table(filePath,sep=",",header=None) # 间隔符为逗号，无标题行        else:            print("不支持的文件格式。")    except Exception as e:        print("读取数据文件失败：{}".format(str(e)))        return    return dfFile# 主程序def main():    # 读取数据文件    readPath = "../data/toothpaste.csv"  # 数据文件的地址和文件名    dfFile = readDataFile(readPath)  # 调用读取文件子程序        print(type(dfFile))  # 查看 dfFile 数据类型    print(dfFile.shape)  # 查看 dfFile 形状（行数，列数）    print(dfFile.head())  # 显示 dfFile 前 5 行数据    returnif __name__ == '__main__':    main()

二、线性规划

1.什么是线性规划问题

2.线性规划问题如何求解

1.问题

2.代码

import pulp  # 导入 PuLP库函数# 1.定义一个规划问题MyProbLP = pulp.LpProblem("LPProbDemo1", sense=pulp.LpMaximize)'''pulp.LpProblem 是定义问题的构造函数。"LPProbDemo1"是用户定义的问题名（用于输出信息）。参数 sense 用来指定求最小值/最大值问题，可选参数值：LpMinimize、LpMaximize 。本例 “sense=pulp.LpMaximize” 表示求目标函数的最大值。'''# 2.定义决策变量x1 = pulp.LpVariable('x1', lowBound=0, upBound=7, cat='Continuous')x2 = pulp.LpVariable('x2', lowBound=0, upBound=7, cat='Continuous')x3 = pulp.LpVariable('x3', lowBound=0, upBound=7, cat='Continuous')'''pulp.LpVariable 是定义决策变量的函数。‘x1’ 是用户定义的变量名。参数 lowBound、upBound 用来设定决策变量的下界、上界；可以不定义下界/上界，默认的下界/上界是负无穷/正无穷。本例中 x1,x2,x3 的取值区间为 [0,7]。参数 cat 用来设定变量类型，可选参数值：‘Continuous’ 表示连续变量（默认值）、’ Integer ’ 表示离散变量（用于整数规划问题）、’ Binary ’ 表示0/1变量（用于0/1规划问题）。'''# 3.设置目标函数MyProbLP += 2 * x1 + 3 * x2 - 5 * x3'''添加目标函数使用 “问题名 += 目标函数式” 格式。'''# 4.添加约束条件MyProbLP += (2 * x1 - 5 * x2 + x3 >= 10)  # 不等式约束MyProbLP += (x1 + 3 * x2 + x3 <= 12)  # 不等式约束MyProbLP += (x1 + x2 + x3 == 7)  # 等式约束'''添加约束条件使用 “问题名 += 约束条件表达式” 格式。约束条件可以是等式约束或不等式约束，不等式约束可以是 小于等于 或 大于等于，分别使用关键字">="、"<=“和”=="。'''# 5.求解MyProbLP.solve()print("Status:", pulp.LpStatus[MyProbLP.status])  # 输出求解状态for v in MyProbLP.variables():    print(v.name, "=", v.varValue)  # 输出每个变量的最优值print("F(x) = ", pulp.value(MyProbLP.objective))  # 输出最优解的目标函数值'''solve() 是求解函数。PuLP默认采用 CBC 求解器来求解优化问题，也可以调用其它的优化器来求解，如：GLPK，COIN CLP/CBC，CPLEX，和GUROBI，但需要另外安装。'''

3.结果

4.求解实例

三、整数规划

线性规划问题的最优解可能是分数或小数。整数规划是指变量的取值只能是整数的规划。
pulp.LpVariable 用来定义决策变量的函数，参数 cat 用来设定变量类型，可选参数值：‘Continuous’ 表示连续变量（默认值）、’ Integer ’ 表示离散变量（用于整数规划问题）、’ Binary ’ 表示0/1变量（用于0/1规划问题）。

1.求解示例

import pulp      # 导入 pulp 库# 主程序def main():    # 模型参数设置    """    问题描述：        某厂生产甲乙两种饮料，每百箱甲饮料需用原料6千克、工人10名，获利10万元；每百箱乙饮料需用原料5千克、工人20名，获利9万元。        今工厂共有原料60千克、工人150名，又由于其他条件所限甲饮料产量不超过8百箱。        （1）问如何安排生产计划，即两种饮料各生产多少使获利最大？        （2）若投资0.8万元可增加原料1千克，是否应作这项投资？投资多少合理？        （3）若不允许散箱（按整百箱生产），如何安排生产计划，即两种饮料各生产多少使获利最大？        （4）若不允许散箱（按整百箱生产），若投资0.8万元可增加原料1千克，是否应作这项投资？投资多少合理？    """    # 问题 1：    """    问题建模：        决策变量：            x1：甲饮料产量（单位：百箱）            x2：乙饮料产量（单位：百箱）        目标函数：            max fx = 10*x1 + 9*x2        约束条件：            6*x1 + 5*x2 <= 60            10*x1 + 20*x2 <= 150                        x1, x2 >= 0，x1 <= 8    此外，由 x1,x2>=0 和 10*x1+20*x2<=150 可知 0<=x2<=7.5    """    ProbLP1 = pulp.LpProblem("ProbLP1", sense=pulp.LpMaximize)    # 定义问题 1，求最大值    x1 = pulp.LpVariable('x1', lowBound=0, upBound=8, cat='Continuous')  # 定义 x1    x2 = pulp.LpVariable('x2', lowBound=0, upBound=7.5, cat='Continuous')  # 定义 x2    ProbLP1 += (10*x1 + 9*x2)  # 设置目标函数 f(x)    ProbLP1 += (6*x1 + 5*x2 <= 60)  # 不等式约束    ProbLP1 += (10*x1 + 20*x2 <= 150)  # 不等式约束    ProbLP1.solve()    print(ProbLP1.name)  # 输出求解状态    print("Status :", pulp.LpStatus[ProbLP1.status])  # 输出求解状态    for v in ProbLP1.variables():        print(v.name, "=", v.varValue)  # 输出每个变量的最优值    print("F1(x) =", pulp.value(ProbLP1.objective))  # 输出最优解的目标函数值    # 问题 2：    """    问题建模：        决策变量：            x1：甲饮料产量（单位：百箱）            x2：乙饮料产量（单位：百箱）            x3：增加投资（单位：万元）        目标函数：            max fx = 10*x1 + 9*x2 - x3        约束条件：            6*x1 + 5*x2 <= 60 + x3/0.8            10*x1 + 20*x2 <= 150            x1, x2, x3 >= 0，x1 <= 8    此外，由 x1,x2>=0 和 10*x1+20*x2<=150 可知 0<=x2<=7.5    """    ProbLP2 = pulp.LpProblem("ProbLP2", sense=pulp.LpMaximize)    # 定义问题 2，求最大值    x1 = pulp.LpVariable('x1', lowBound=0, upBound=8, cat='Continuous')  # 定义 x1    x2 = pulp.LpVariable('x2', lowBound=0, upBound=7.5, cat='Continuous')  # 定义 x2    x3 = pulp.LpVariable('x3', lowBound=0, cat='Continuous')  # 定义 x3    ProbLP2 += (10*x1 + 9*x2 - x3)  # 设置目标函数 f(x)    ProbLP2 += (6*x1 + 5*x2 - 1.25*x3 <= 60)  # 不等式约束    ProbLP2 += (10*x1 + 20*x2 <= 150)  # 不等式约束    ProbLP2.solve()    print(ProbLP2.name)  # 输出求解状态    print("Status :", pulp.LpStatus[ProbLP2.status])  # 输出求解状态    for v in ProbLP2.variables():        print(v.name, "=", v.varValue)  # 输出每个变量的最优值    print("F2(x) =", pulp.value(ProbLP2.objective))  # 输出最优解的目标函数值    # 问题 3：整数规划问题    """    问题建模：        决策变量：            x1：甲饮料产量，正整数（单位：百箱）            x2：乙饮料产量，正整数（单位：百箱）        目标函数：            max fx = 10*x1 + 9*x2        约束条件：            6*x1 + 5*x2 <= 60            10*x1 + 20*x2 <= 150            x1, x2 >= 0，x1 <= 8，x1, x2 为整数    此外，由 x1,x2>=0 和 10*x1+20*x2<=150 可知 0<=x2<=7.5    """    ProbLP3 = pulp.LpProblem("ProbLP3", sense=pulp.LpMaximize)  # 定义问题 3，求最大值    print(ProbLP3.name)  # 输出求解状态    x1 = pulp.LpVariable('x1', lowBound=0, upBound=8, cat='Integer')  # 定义 x1，变量类型：整数    x2 = pulp.LpVariable('x2', lowBound=0, upBound=7.5, cat='Integer')  # 定义 x2，变量类型：整数    ProbLP3 += (10 * x1 + 9 * x2)  # 设置目标函数 f(x)    ProbLP3 += (6 * x1 + 5 * x2 <= 60)  # 不等式约束    ProbLP3 += (10 * x1 + 20 * x2 <= 150)  # 不等式约束    ProbLP3.solve()    print("Status:", pulp.LpStatus[ProbLP3.status])  # 输出求解状态    for v in ProbLP3.variables():        print(v.name, "=", v.varValue)  # 输出每个变量的最优值    print("F3(x) =", pulp.value(ProbLP3.objective))  # 输出最优解的目标函数值    # 问题 4：    """    问题建模：        决策变量：            x1：甲饮料产量，正整数（单位：百箱）            x2：乙饮料产量，正整数（单位：百箱）            x3：增加投资（单位：万元）        目标函数：            max fx = 10*x1 + 9*x2 - x3        约束条件：            6*x1 + 5*x2 <= 60 + x3/0.8            10*x1 + 20*x2 <= 150            x1, x2, x3 >= 0，x1 <= 8，x1, x2 为整数    此外，由 x1,x2>=0 和 10*x1+20*x2<=150 可知 0<=x2<=7.5    """    ProbLP4 = pulp.LpProblem("ProbLP4", sense=pulp.LpMaximize)  # 定义问题 4，求最大值    print(ProbLP4.name)  # 输出求解状态    x1 = pulp.LpVariable('x1', lowBound=0, upBound=8, cat='Integer')  # 定义 x1，变量类型：整数    x2 = pulp.LpVariable('x2', lowBound=0, upBound=7, cat='Integer')  # 定义 x2，变量类型：整数    x3 = pulp.LpVariable('x3', lowBound=0, cat='Continuous')  # 定义 x3    ProbLP4 += (10*x1 + 9*x2 - x3)  # 设置目标函数 f(x)    ProbLP4 += (6*x1 + 5*x2 - 1.25*x3 <= 60)  # 不等式约束    ProbLP4 += (10*x1 + 20*x2 <= 150)  # 不等式约束    ProbLP4.solve()    print("Status:", pulp.LpStatus[ProbLP4.status])  # 输出求解状态    for v in ProbLP4.variables():        print(v.name, "=", v.varValue)  # 输出每个变量的最优值    print("F4(x) =", pulp.value(ProbLP4.objective))  # 输出最优解的目标函数值    returnif __name__ == '__main__':      main()  

2.结果

四、0-1规划

0-1 整数规划是一类特殊的整数规划，变量的取值只能是 0 或 1。主要用于求解互斥的决策问题、互斥的约束条件问题、固定费用问题和分派问题。

1.规划的分类及建模方法

规划问题的数学模型包括决策变量、约束条件和目标函数，围绕这三个要素都可能存在互斥的情况，从而导出不同类型的0-1规划问题，其建模方法也有差别。

• 1.互斥的决策问题
  
• 2.互斥的约束问题
  
• 3.固定费用问题
  
• 4.指派问题
  

2.PuLP 求解 0-1 规划问题

案例问题描述

2.建模过程分析

模型求解的编程

import pulp      # 导入 pulp 库# 主程序def main():    # 投资决策问题：    # 公司现有 5个拟投资项目，根据投资额、投资收益和限制条件，问如何决策使收益最大。    """    问题建模：        决策变量：            x1～x5：0/1 变量，1 表示选择第 i 个项目， 0 表示不选择第 i 个项目        目标函数：            max fx = 150*x1 + 210*x2 + 60*x3 + 80*x4 + 180*x5        约束条件：            210*x1 + 300*x2 + 100*x3 + 130*x4 + 260*x5 <= 600            x1 + x2 + x3 = 1            x3 + x4 <= 1            x5 <= x1            x1,...,x5 = 0, 1    """    InvestLP = pulp.LpProblem("Invest decision problem", sense=pulp.LpMaximize)  # 定义问题，求最大值    # 参数 cat 用来设定变量类型，’ Binary ’ 表示0/1变量（用于0/1规划问题）。    x1 = pulp.LpVariable('A', cat='Binary')  # 定义 x1，A 项目       x2 = pulp.LpVariable('B', cat='Binary')  # 定义 x2，B 项目    x3 = pulp.LpVariable('C', cat='Binary')  # 定义 x3，C 项目    x4 = pulp.LpVariable('D', cat='Binary')  # 定义 x4，D 项目    x5 = pulp.LpVariable('E', cat='Binary')  # 定义 x5，E 项目    InvestLP += (150*x1 + 210*x2 + 60*x3 + 80*x4 + 180*x5)  # 设置目标函数 f(x)    InvestLP += (210*x1 + 300*x2 + 100*x3 + 130*x4 + 260*x5 <= 600)  # 不等式约束    InvestLP += (x1 + x2 + x3 == 1)  # 等式约束    InvestLP += (x3 + x4 <= 1)  # 不等式约束    InvestLP += (x5 - x1 <= 0)  # 不等式约束    InvestLP.solve()  # solve() 是求解函数，可以对求解器、求解精度进行设置。    print(InvestLP.name)  # 输出求解状态    print("Status youcans:", pulp.LpStatus[InvestLP.status])  # 输出求解状态    for v in InvestLP.variables():        print(v.name, "=", v.varValue)  # 输出每个变量的最优值    print("Max f(x) =", pulp.value(InvestLP.objective))  # 输出最优解的目标函数值    returnif __name__ == '__main__':     main()  

运行结果

结论：从 0-1 规划模型的结果可知，选择 A、C、E 项目进行投资，可以满足限定条件并获得最大收益 410万元。

五、固定费用问题

1.问题定义

2.案例

问题描述

2.建模分析
首先要理解生产某种服装就会发生设备租金，租金只与是否生产该产品有关，而与生产数量无关，这就是固定成本。因此本题属于固定费用问题。
有些同学下意识地认为是从 3 种产品中选择一种，但题目中并没有限定必须或只能生产一种产品，因此决策结果可以是都不生产、选择 1 种或 2 种产品、3 种都生产。

3.编程求解

import pulp      # 导入 pulp 库# 主程序def main():    # 固定费用问题(Fixed cost problem)    print("固定费用问题(Fixed cost problem)")    # 问题建模：    """        决策变量：            y(i) = 0, 不生产第 i 种产品            y(i) = 1, 生产第 i 种产品                        x(i), 生产第 i 种产品的数量, i>=0 整数            i=1,2,3        目标函数：            min profit = 120x1 + 10x2+ 100x3 - 5000y1 - 2000y2 - 2000y3        约束条件：            5x1 + x2 + 4x3 <= 2000            3x1 <= 300y1            0.5x2 <= 300y2            2x3 <= 300y3        变量取值范围：            0<=x1<=100, 0<=x2<=600, 0<=x3<=150, 整数变量            y1, y2 ,y3 为 0/1 变量     """    # 1. 固定费用问题(Fixed cost problem), 使用 PuLP 工具包求解    # (1) 建立优化问题 FixedCostP1: 求最大值(LpMaximize)    FixedCostP1 = pulp.LpProblem("Fixed_cost_problem_1", sense=pulp.LpMaximize)  # 定义问题，求最大值    # (2) 建立变量    x1 = pulp.LpVariable('A', cat='Binary')  # 定义 x1，0-1变量，是否生产 A 产品    x2 = pulp.LpVariable('B', cat='Binary')  # 定义 x2，0-1变量，是否生产 B 产品    x3 = pulp.LpVariable('C', cat='Binary')  # 定义 x3，0-1变量，是否生产 C 产品    y1 = pulp.LpVariable('yieldA', lowBound=0, upBound=100, cat='Integer')  # 定义 y1，整型变量    y2 = pulp.LpVariable('yieldB', lowBound=0, upBound=600, cat='Integer')  # 定义 y2，整型变量    y3 = pulp.LpVariable('yieldC', lowBound=0, upBound=150, cat='Integer')  # 定义 y3，整型变量    # (3) 设置目标函数    FixedCostP1 += pulp.lpSum(-5000*x1-2000*x2-2000*x3+120*y1+10*y2+100*y3)  # 设置目标函数 f(x)    # (4) 设置约束条件    FixedCostP1 += (5*y1 + y2 + 4*y3 <= 2000)  # 不等式约束    FixedCostP1 += (3*y1 - 300*x1 <= 0)  # 不等式约束    FixedCostP1 += (0.5*y2 - 300*x2 <= 0)  # 不等式约束    FixedCostP1 += (2*y3 - 300*x3 <= 0)  # 不等式约束    # (5) 求解    FixedCostP1.solve()    # (6) 打印结果    print(FixedCostP1.name)    if pulp.LpStatus[FixedCostP1.status] == "Optimal":  # 获得最优解        for v in FixedCostP1.variables():            print(v.name, "=", v.varValue)  # 输出每个变量的最优值        print("F(x) = ", pulp.value(FixedCostP1.objective))  # 输出最优解的目标函数值    returnif __name__ == '__main__':    main()

结论：从固定费用问题模型的求解结果可知，A、B、C 三种服装都生产，产量分别为 A/100、B/600、C/150 时获得最大利润为：24000。

字典格式快捷建模方法

import pulp  # 导入 pulp 库# 主程序def main():    # 2. 问题同上，PuLP 快捷方法示例    # (1) 建立优化问题 FixedCostP2: 求最大值(LpMaximize)    FixedCostP2 = pulp.LpProblem("Fixed_cost_problem_2", sense=pulp.LpMaximize)  # 定义问题，求最大值    # (2) 建立变量    types = ['A', 'B', 'C']  # 定义产品种类    status = pulp.LpVariable.dicts("生产决策", types, cat='Binary')  # 定义 0/1 变量，是否生产该产品    yields = pulp.LpVariable.dicts("生产数量", types, lowBound=0, upBound=600, cat='Integer')  # 定义整型变量    # (3) 设置目标函数    fixedCost = {'A': 5000, 'B': 2000, 'C': 2000}  # 各产品的 固定费用    unitProfit = {'A': 120, 'B': 10, 'C': 100}  # 各产品的 单位利润    FixedCostP2 += pulp.lpSum([(yields[i] * unitProfit[i] - status[i] * fixedCost[i]) for i in types])    # (4) 设置约束条件    humanHours = {'A': 5, 'B': 1, 'C': 4}  # 各产品的 单位人工工时    machineHours = {'A': 3.0, 'B': 0.5, 'C': 2.0}  # 各产品的 单位设备工时    maxHours = {'A': 300, 'B': 300, 'C': 300}  # 各产品的 最大设备工时    FixedCostP2 += pulp.lpSum([humanHours[i] * yields[i] for i in types]) <= 2000  # 不等式约束    for i in types:        FixedCostP2 += (yields[i] * machineHours[i] - status[i] * maxHours[i] <= 0)  # 不等式约束    # (5) 求解    FixedCostP2.solve()    # (6) 打印结果    print(FixedCostP2.name)    temple = "品种 %(type)s 的决策是：%(status)s，生产数量为：%(yields)d"    if pulp.LpStatus[FixedCostP2.status] == "Optimal":  # 获得最优解        for i in types:            output = {'type': i,                      'status': '同意' if status[i].varValue else '否决',                      'yields': yields[i].varValue}            print(temple % output)        print("最大利润 = ", pulp.value(FixedCostP2.objective))  # 输出最优解的目标函数值    returnif __name__ == '__main__':    main()

六、选址问题

选址问题是指在某个区域内选择设施的位置使所需的目标达到最优。选址问题也是一种互斥的计划问题。
选址问题有四个基本要素：设施、区域、距离和优化目标。

1.P-中位问题

2.P-中心问题

3.集合覆盖问题

4.游泳接力赛的指派问题

import pulp      # 导入 pulp 库import numpy as np# 主程序def main():    # 问题建模：    """        决策变量：            x(i,j) = 0, 第 i 个人不游第 j 种姿势            x(i,j) = 1, 第 i 个人游第 j 种姿势            i=1,4, j=1,4        目标函数：            min time = sum(sum(c(i,j)*x(i,j))), i=1,4, j=1,4        约束条件：            sum(x(i,j),j=1,4)=1, i=1,4            sum(x(i,j),i=1,4)=1, j=1,4        变量取值范围：            x(i,j) = 0,1     """    # 游泳比赛的指派问题 (assignment problem)    # 1.建立优化问题 AssignLP: 求最小值(LpMinimize)    AssignLP = pulp.LpProblem("Assignment_problem_for_swimming_relay_race", sense=pulp.LpMinimize)  # 定义问题，求最小值    # 2. 建立变量    rows = cols = range(0, 4)    x = pulp.LpVariable.dicts("x", (rows, cols), cat="Binary")    # 3. 设置目标函数    scoreM = [[56,74,61,63],[63,69,65,71],[57,77,63,67],[55,76,62,62]]    AssignLP += pulp.lpSum([[x[row][col]*scoreM[row][col] for row in rows] for col in cols])    # 4. 施加约束    for row in rows:        AssignLP += pulp.lpSum([x[row][col] for col in cols]) == 1 # sum(x(i,j),j=1,4)=1, i=1,4    for col in cols:        AssignLP += pulp.lpSum([x[row][col] for row in rows]) == 1 # sum(x(i,j),i=1,4)=1, j=1,4    # 5. 求解    AssignLP.solve()    # 6. 打印结果    print(AssignLP.name)    member = ["队员A","队员B","队员C","队员D"]    style = ["自由泳","蛙泳","蝶泳","仰泳"]    if pulp.LpStatus[AssignLP.status] == "Optimal":  # 获得最优解        xValue = [v.varValue for v in AssignLP.variables()]        # [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]        xOpt = np.array(xValue).reshape((4, 4))  # 将 xValue 格式转换为 4x4 矩阵        print("最佳分配：" )        for row in rows:            print("{}\t{} 参加项目：{}".format(xOpt[row],member[row],style[np.argmax(xOpt[row])]))        print("预测最好成绩为：{}".format(pulp.value(AssignLP.objective)))    returnif __name__ == '__main__':    main()

5.消防站的选址问题

import pulp  # 导入 pulp 库# 主程序def main():    # 问题建模：    """        决策变量：            x(j) = 0, 不选择第 j 个消防站            x(j) = 1, 选择第 j 个消防站, j=1,8        目标函数：            min fx = sum(x(j)), j=1,8        约束条件：            sum(x(j)*R(i,j),j=1,8) >=1, i=1,8        变量取值范围：            x(j) = 0,1    """    # 消防站的选址问题 (set covering problem, site selection of fire station)    # 1.建立优化问题 SetCoverLP: 求最小值(LpMinimize)    SetCoverLP = pulp.LpProblem("SetCover_problem_for_fire_station", sense=pulp.LpMinimize)  # 定义问题，求最小值    # 2. 建立变量    zones = list(range(8))  # 定义各区域    x = pulp.LpVariable.dicts("zone", zones, cat="Binary")  # 定义 0/1 变量，是否在该区域设消防站    # 3. 设置目标函数    SetCoverLP += pulp.lpSum([x[j] for j in range(8)])  # 设置消防站的个数    # 4. 施加约束    reachable = [[1, 0, 0, 0, 0, 0, 0, 0],                 [0, 1, 1, 0, 0, 0, 0, 0],                 [0, 1, 1, 0, 1, 0, 0, 0],                 [0, 0, 0, 1, 0, 0, 0, 0],                 [0, 0, 0, 0, 1, 0, 0, 0],                 [0, 0, 0, 0, 0, 1, 1, 0],                 [0, 0, 0, 0, 0, 0, 1, 1],                 [0, 0, 0, 0, 0, 0, 1, 1]]  # 参数矩阵，第 i 消防站能否在 10分钟内到达第 j 区域    for i in range(8):        SetCoverLP += pulp.lpSum([x[j] * reachable[j][i] for j in range(8)]) >= 1    # 5. 求解    SetCoverLP.solve()    # 6. 打印结果    print(SetCoverLP.name)    temple = "区域 %(zone)d 的决策是：%(status)s"  # 格式化输出    if pulp.LpStatus[SetCoverLP.status] == "Optimal":  # 获得最优解        for i in range(8):            output = {'zone': i + 1,  # 与问题中区域 1~8 一致                      'status': '建站' if x[i].varValue else '--'}            print(temple % output)        print("需要建立 {} 个消防站。".format(pulp.value(SetCoverLP.objective)))    returnif __name__ == '__main__':    main()

来源地址：https://blog.csdn.net/m0_46692607/article/details/126784109