2024年数学建模比赛题目及解题代码

数学建模竞赛，作为一项集知识性、创新性与实践性于一体的国际性赛事，旨在培养学生运用数学理论与方法解决实际问题的能力。它要求参赛者针对现实生活中的复杂问题，通过深入的分析、抽象与建模，最终提出科学合理的解决方案。数学建模竞赛不仅考验了学生的数学基础，更重要的是锻炼了他们的逻辑思维能力、团队合作精神以及创新能力。在这个过程中，学生需要将抽象的数学理论与具体的应用场景相结合，创造出既有理论深度又具实用价值的模型。

在数学建模竞赛中，问题类型多样，涵盖自然科学、社会科学、工程技术等多个领域。其中，生产过程中的决策问题因其贴近实际、复杂多变而备受关注。这类问题往往涉及到资源分配、生产调度、成本控制等多个方面，要求参赛者能够全面把握问题的核心，准确识别关键变量，并设计出高效、可靠的数学模型进行求解。

1.1.2生产过程决策问题在竞赛中的重要性

生产过程决策问题在数学建模竞赛中占据举足轻重的地位。首先，从现实意义上看，生产过程是企业运营的核心环节，其决策质量直接关系到企业的生产效率、成本控制和市场竞争能力。因此，研究生产过程决策问题不仅有助于提升企业自身的竞争力，还能为整个行业乃至社会的可持续发展贡献力量。

从竞赛难度和挑战性来看，生产过程决策问题往往涉及多个变量和约束条件，需要参赛者具备深厚的数学功底、敏锐的问题洞察力和创新的建模思路。这类问题的解决不仅考验了学生的数学建模能力，还促进了他们在交叉学科领域的知识融合与创新。

从人才培养的角度来看，通过参与生产过程决策问题的建模竞赛，学生可以更好地将所学的数学理论知识与实际应用相结合，提升解决实际问题的能力。同时，这种跨学科的实践经历也有助于拓宽学生的视野，增强他们的创新精神和团队协作能力。因此，生产过程决策问题在数学建模竞赛中具有重要的教育意义和实际应用价值。

1.2 解题前准备

1.2.1 团队组建与角色分配

在解决生产过程中的决策问题时，一个协作默契、优势互补的团队是成功的关键。因此，在解题前，首要任务是组建一个高效的团队，并根据成员的专业背景和技能特长进行合理的角色分配。团队中应有负责问题分析与抽象的"分析师"，有擅长数学建模与算法设计的"建模师"，还有能够熟练运用软件进行计算与仿真的"程序员"。通过明确各成员的角色定位，可以确保团队在解题过程中各司其职，协同作战，共同攻克难题。

1.2.2 工具与资源准备

工具与资源的准备也是解题前不可或缺的一环。针对生产过程中的决策问题，可能需要使用到专业的数学建模软件（如MATLAB、Lingo、Python及其相关库）来构建和求解模型。此外，还需要收集相关的文献资料、数据资源和行业报告，以便深入了解问题背景、行业现状和市场需求。这些工具和资源的准备将为后续的解题工作提供有力的支持，确保解题过程的顺利进行。

1.2.3 心态调整与策略规划

在解题前，良好的心态和明确的策略规划同样重要。面对复杂多变的生产过程决策问题，参赛者需要保持冷静、自信的心态，克服畏难情绪和急躁心理。同时，还需要根据问题的特点和团队的优势，制定出一套切实可行的解题策略。这包括明确解题目标、分解问题步骤、确定时间节点、预留调整空间等。通过合理的策略规划，可以确保团队在解题过程中有条不紊地推进工作，提高解题效率和质量。

二、问题理解与分析

企业将两个零配件装配成成品。在装配的成品中，只要其中一个零配件不合格，则成品一定不合格；如果两个零配件均合格，装配出的成品也不一定合格。对于不合格成品，企业可以选择报废，或者对其进行拆解，拆解过程不会对零配件造成损坏，但需要花费拆解费用。请建立数学模型，解决以下问题：

问题 1 供应商声称一批零配件（零配件 1 或零配件 2）的次品率不会超过某个标称值。企业准备采用抽样检测方法决定是否接收从供应商购买的这批零配件，检测费用由企业自行承担。请为企业设计检测次数尽可能少的抽样检测方案。如果标称值为 10%，根据你们的抽样检测方案，针对以下两种情形，分别给出具体结果：

(1) 在 95%的信度下认定零配件次品率超过标称值，则拒收这批零配件；

(2) 在 90%的信度下认定零配件次品率不超过标称值，则接收这批零配件。

问题 2 已知两种零配件和成品次品率，请为企业生产过程的各个阶段作出决策：

(1) 对零配件（零配件 1 和/或零配件 2）是否进行检测，如果对某种零配件不检测，这

种零配件将直接进入到装配环节；否则将检测出的不合格零配件丢弃；

(2) 对装配好的每一件成品是否进行检测，如果不检测，装配后的成品直接进入到市场；否则只有检测合格的成品进入到市场；

(3) 对检测出的不合格成品是否进行拆解，如果不拆解，直接将不合格成品丢弃；否则对拆解后的零配件，重复步骤(1)和步骤(2)；

(4) 对用户购买的不合格品，企业将无条件予以调换，并产生一定的调换损失（如物流成本、企业信誉等）。对退回的不合格品，重复步骤(3)。请根据你们所做的决策，对表 1 中的情形给出具体的决策方案，并给出决策的依据及相应的指标结果。

表 1 企业在生产中遇到的情况（问题 2 ）

三、模型构建与求解

3.1 模型选择与设计

3.1.1 根据问题特性选择合适的数学模型类型

针对生产过程中的决策问题，本次选择了混合整数线性规划（Mixed Integer Linear Programming, MILP）模型。这类模型适用于解决既包含连续变量又包含整数或二进制变量的优化问题，特别适用于决策过程中需要做出是否测试（二元决策）以及成本收益计算（连续变量）的场景。在本问题中，本次需要确定是否对零配件和装配过程进行测试，以及是否拆解有缺陷的产品，这些都是典型的二元决策问题；同时，本次还需要计算各种成本（如购买成本、测试成本、拆解成本等）和收入，这些则是连续变量的优化问题。因此，MILP模型是解决此类问题的理想选择。

3.1.2 设计模型框架，定义变量、参数和方程

在模型框架设计中，本次首先定义了决策变量（test_part1, test_part2, test_assembly, disassemble），它们都是二进制变量，用于表示是否执行相应的测试或拆解操作。接着，本次定义了多个参数（如缺陷率、成本、市场价格、损失等），这些参数在模型中作为已知常数，用于计算成本和收入。然后，本次根据问题描述构建了目标函数，即最大化净利润，它是总收入减去总成本的差。最后，本次根据业务逻辑和实际情况，设置了两个关键的约束条件：一是至少测试一个零配件，二是当且仅当装配测试发现缺陷时才进行拆解。

3.2 模型构建

3.2.1 构建目标函数，反映生产决策的优化目标

目标函数是模型构建的核心，它直接反映了生产决策的优化目标。在本问题中，本次的目标是最大化净利润，即总收入减去总成本。总收入与产品的市场价格、销售数量和装配测试的结果有关；而总成本则包括零配件和装配的购买成本、测试成本、拆解成本、替换损失以及声誉损失等多个部分。通过将这些因素综合考虑，本次构建了目标函数，用于指导求解过程。

3.2.2 将所有约束条件转化为模型中的约束方程

在构建模型时，本次需要确保所有决策都符合业务逻辑和实际情况。因此，本次将问题中的约束条件转化为模型中的约束方程。在本问题中，本次设置了两个关键的约束条件：一是至少测试一个零配件（以确保产品质量），二是当且仅当装配测试发现缺陷时才进行拆解（以避免不必要的拆解成本）。通过将这两个条件转化为数学表达式，本次得到了两个约束方程，它们限制了决策变量的取值范围，确保了求解结果的合理性和可行性。

3.2.3 检查模型的有效性和合理性

在构建完模型后，本次需要对其进行有效性和合理性的检查。这包括检查模型的逻辑是否正确、参数是否合理、约束条件是否完整以及目标函数是否能够准确反映优化目标等方面。通过反复检查和验证，本次确保了模型的有效性和合理性，为后续的求解工作打下了坚实的基础。

3.3 模型求解

3.3.1 选择合适的求解算法或工具

在模型求解阶段，本次选择了PuLP作为求解工具。PuLP是一个开源的线性规划库，它提供了丰富的接口和功能来构建和求解线性规划、整数规划以及混合整数线性规划等问题。通过PuLP库，本次可以方便地定义变量、参数、目标函数和约束条件，并调用求解器进行求解。在本问题中，本次使用了PuLP默认的求解器来求解模型。

3.3.2 进行模型求解，获取初步结果

在确定了求解算法和工具后，本次进行了模型求解。通过调用PuLP库中的solve()函数，本次获得了模型的初步解。这些解包括决策变量的取值（是否测试、是否拆解等）以及目标函数的值（净利润）。这些结果为本次后续的分析和决策提供了重要的参考依据。

3.3.3 对结果进行初步分析，检查是否符合预期

在获得初步结果后，本次对其进行了初步的分析和检查。首先，本次检查了决策变量的取值是否符合业务逻辑和实际情况；其次，本次计算了目标函数的值（净利润），并与预期进行了比较；最后，本次还分析了各个成本项和收入项对净利润的影响程度。通过这些分析和检查，本次验证了模型的有效性和准确性，并为后续的决策优化提供了有益的指导。

四、结果验证与优化

4.1结果验证

4.1.1 实际情况或常识对比验证

在结果验证阶段，本次首先需要将模型结果与实际情况或行业常识进行对比。例如，如果模型建议在所有阶段都进行测试，但实际上某些测试成本过高且效果不明显，这可能不符合行业最佳实践。

测试决策：如果模型输出显示所有部件和装配都应测试，本次需要考虑这是否符合经济性和实际可行性。例如，如果某些部件的缺陷率极低且测试成本高昂，那么在实际中可能更倾向于不进行测试。

拆解决策：对于模型输出的拆解决策，本次需要评估这一决策是否能有效减少替换损失和声誉损失。如果拆解成本过高，而替换损失和声誉损失相对较小，那么拆解可能不是最优选择。

成本效益：比较模型计算出的总成本和总收入，与常识或行业标准进行比较，确保模型的预测在合理范围内。

4.1.2 分析模型假设的合理性

本模型的假设包括：

二元决策：假设每个测试和拆解决策都是二元的（测试或不测试，拆解或不拆解），这在现实中可能是合理的，但也忽略了可能存在的部分测试或拆解的情况。

成本固定：假设所有成本都是固定的，没有考虑规模经济或批量折扣。

缺陷率独立：假设不同部件和装配的缺陷率独立，但实际上可能存在相关性。

这些假设的合理性将直接影响模型结果的准确性。例如，如果测试成本存在显著的规模经济，那么模型可能低估了测试的经济性。同样，如果部件之间的缺陷率存在强相关性，那么模型可能未能充分捕捉到这种依赖关系。

4.2模型优化

4.2.1 调整模型参数或假设

基于验证结果，本次可以调整模型的参数或假设以改进模型。例如：

考虑测试成本的规模经济：如果测试成本随测试数量的增加而降低，本次可以在模型中引入一个递减的测试成本函数。

引入多阶段测试：将测试细分为多个阶段，每个阶段有不同的测试成本和准确性，以更精确地反映现实情况。

考虑缺陷率的相关性：使用统计方法估计部件之间缺陷率的相关性，并在模型中引入这些相关性。

4.2.2 尝试不同的求解算法或模型结构

为了改进结果，本次可以尝试使用不同的求解算法或模型结构：

使用混合整数线性规划（MILP）求解器：如果当前使用的求解器在求解大规模问题时效率较低，可以尝试使用其他高效的MILP求解器。

引入随机优化：如果某些参数（如缺陷率）存在不确定性，可以使用随机优化方法来考虑这些不确定性对决策的影响。

采用机器学习模型：如果数据量足够大，可以使用机器学习模型来预测成本和收入，并基于预测结果做出决策。

4.2.3 评估不同优化方案的优缺点

在评估不同优化方案时，本次需要考虑每个方案的优缺点：

引入规模经济的优点：能更准确地反映现实情况，提高模型的预测精度。缺点是需要额外的数据来估计规模经济参数。

多阶段测试的优点：提供了更灵活的测试策略，可能减少总成本。缺点是增加了模型的复杂性。

随机优化的优点：能够处理不确定性，提高决策的鲁棒性。缺点是计算量大，可能需要高级的计算资源。

综合考虑各种因素后，本次可以选择最适合当前情境的优化方案，并对模型进行相应的调整和改进。

五、反思与提升

5.1解题过程反思

5.1.1回顾解题过程中的难点与收获

样本量计算和临界值确定：在计算样本量和临界值时，需要正确理解和应用正态分布的分位数函数（ppf）以及误差估计的公式。这一步骤需要精确的数学推导和对统计学的深入理解。

线性规划建模：在定义solve_decision_problem函数时，如何将实际问题抽象成数学模型，特别是如何处理二进制变量和约束条件，是一个挑战。需要确保所有成本和收入都被准确纳入模型，并且逻辑上无误。

参数调整和敏感性分析：在实际应用中，参数的微小变化可能导致结果的大幅波动。如何调整参数以反映不同的生产环境和市场条件，以及进行敏感性分析来评估这些因素对最终决策的影响，是进一步研究的重点。

增强了统计学知识：通过计算样本量和临界值，加深了对正态分布、置信区间和误差估计的理解。

掌握了线性规划的应用：成功将实际的生产决策问题转化为线性规划问题，并通过求解得到了最优的生产和测试策略。

提升了编程能力：在Python中使用SciPy和PuLP库，实现了从数据处理到模型求解的全过程，提高了编程和问题解决的能力。

5.1.2分析团队合作与个人表现，识别不足之处

团队合作：

在此过程中，如果是一个团队项目，可能需要更加紧密的合作和沟通，特别是在定义问题、设计模型和验证结果时。

团队成员间的分工和协作需要进一步明确，以确保每个部分都能得到有效处理。

个人表现：

在理解和应用统计学原理时，可能会遇到一些困难，需要更多的学习和实践。

在线性规划建模过程中，对约束条件的定义和逻辑关系需要更加严谨和细致，以避免逻辑错误。

5.2知识与能力提升

5.2.1 总结所用到的数学建模知识和方法

统计学知识：利用正态分布的分位数函数（ppf）计算置信区间，掌握了误差估计的方法。

线性规划：通过定义目标函数、约束条件和变量，将实际问题转化为线性规划模型，并使用PuLP库进行求解。

编程技能：在Python中使用了SciPy和PuLP库进行数据处理和模型求解，提高了编程和算法实现的能力。

5.2.2 思考如何将这些知识和方法应用到其他领域或问题中

供应链管理：可以将这些知识和方法应用于供应链优化中，如库存管理、物流规划等。

金融风险管理：在风险评估和投资组合优化中，可以利用统计学原理进行置信区间估计和误差分析。

资源分配问题：在资源有限的情况下，如何合理分配资源以达到最大效益，可以通过线性规划等优化方法来解决。

参考文献

[1]田永丽. 高中生数学建模能力的影响因素及提升对策研究[D]. 贵州师范大学, 2020. DOI:10.27048/d.cnki.ggzsu.2020.000560.

[2]陈玲玲. 不确定环境下供应链计划建模与优化研究[D]. 东北大学, 2012.

[3]李强,刘克辉,石红红. 基于多智能体的产业演进仿真建模 [J]. 统计与决策, 2012, (02): 56-59. DOI:10.13546/j.cnki.tjyjc.2012.02.030.

[4]茅娴莘. 基于Witness仿真的TiW蚀刻机台产能改善研究[D]. 上海交通大学, 2011.

[5]谢毅. 基于独立队列的业务过程调度优化关键技术研究[D]. 浙江大学, 2011.

[6]左龙江. 供应链管理环境下的生产能力规划原理及方法研究[D]. 四川大学, 2006.

[7]梁田甜. 钢铁企业轨梁生产线数字建模与仿真研究[D]. 重庆大学, 2006.

[8]吴元春. 乙醛生产过程优化 [J]. 南京化工大学学报(自然科学版), 2001, (04): 47-49.

六、解题思路

问题1：

抽样检测方案设计

目标：确定最少的抽样数量，以决定是否接收供应商的零配件。

解题思路：

首先，质量控制与决策模型 可以用于零配件的抽样检测问题。基于零配件的次品率和信度要求，可以通过泊松分布或二项分布设计抽样方案。

假设零配件的次品率为p=10%p = 10\%（标称值），设定置信度为 95% 和 90%。我们可以使用如下公式确定最小抽样量

方法：

使用统计学公式或软件工具（如Python的SciPy库）来确定样本量和临界值。

问题2：生产过程决策

目标：为生产过程的各个阶段制定最优决策。

解题思路：

定义决策变量：是否检测零配件、是否检测成品、是否拆解不合格成品。

成本效益分析：计算每个决策的成本和收益。

建立优化模型：使用线性规划来最小化总成本或最大化利润。

方法：

使用pulp库构建和求解线性规划模型。

问题3：

多工序多零配件生产决策

目标：扩展问题2的模型，考虑多道工序和多个零配件。

解题思路：

扩展决策变量：为每个零配件和半成品添加检测和拆解的决策变量。

成本效益分析：计算每个决策的成本和收益，包括半成品和成品的次品率。

建立优化模型：使用线性规划来最小化总成本或最大化利润。

方法：

使用pulp库构建和求解线性规划模型，考虑多工序和多个零配件。

问题4：考虑抽样误差的决策

目标：重新评估问题2和问题3中的决策，考虑抽样误差。

解题思路：

模拟抽样误差：使用统计方法模拟抽样误差对次品率的影响。

重新计算决策：基于模拟的次品率重新计算最优决策。

敏感性分析：分析决策对抽样误差的敏感性。

方法：

使用蒙特卡洛模拟来模拟抽样误差，并重新评估问题2和问题3的决策。

通用步骤

数据收集：收集所有相关的成本、价格和次品率数据。

模型构建：根据问题要求构建数学模型。

模型求解：使用适当的算法或软件工具求解模型。

结果分析：分析模型结果，确定最优决策。

报告撰写：撰写详细的解决方案报告，包括决策方案和决策依据。

七、解题代码

第一题：

这段Python代码用于计算在给定置信度下的抽样检测方案，特别是确定所需的最小样本量和临界次品率。这些计算对于质量控制和抽样检验非常重要，可以帮助企业决定是否接受供应商提供的零配件。以下是代码的详细解释：

python 复制代码

from scipy.stats import norm

这行代码从`scipy.stats`模块导入`norm`，它提供了正态分布相关的函数，包括计算正态分布的分位数。

python 复制代码

# 参数设置
p0 = 0.10  # 标称次品率
confidence_95 = 0.95
confidence_90 = 0.90
e = 0.05  # 抽样误差

`p0`: 标称次品率，即供应商声称的次品率，这里是10%。
`confidence_95` 和 `confidence_90`: 分别是95%和90%置信度，用于计算所需的样本量和临界值。
`e`: 抽样误差，即允许的误差范围，这里是5%。

python 复制代码

# 置信度对应的Z值
z_95 = norm.ppf(1 - (1 - confidence_95) / 2)
z_90 = norm.ppf(1 - (1 - confidence_90) / 2)

`norm.ppf`: 这是正态分布的百分点函数，用于计算给定置信度下的Z值（分位数）。
`z_95` 和 `z_90`: 分别是95%和90%置信度下的Z值。

python 复制代码

# 计算样本量
n_95 = (z_95 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
n_90 = (z_90 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2

print(f"Sample size for 95% confidence level: {n_95:.2f}")
print(f"Sample size for 90% confidence level: {n_90:.2f}")

这些公式用于计算在给定置信度和误差范围内所需的最小样本量。
`(p0 * (1 - p0)) ** 0.5`: 这是二项分布的标准差，用于计算样本量。
`n_95` 和 `n_90`: 分别是95%和90%置信度下的样本量。
这些行代码打印出在95%和90%置信度下所需的样本量。

python 复制代码

# 计算临界值
critical_value_95 = p0 + z_95 * (e / ((p0 * (1 - p0)) ** 0.5))
critical_value_90 = p0 + z_90 * (e / ((p0 * (1 - p0)) ** 0.5))

print(f"Critical value for 95% confidence level: {critical_value_95:.4f}")
print(f"Critical value for 90% confidence level: {critical_value_90:.4f}")

这些公式用于计算在给定置信度下的临界次品率。
`critical_value_95` 和 `critical_value_90`: 分别是95%和90%置信度下的临界值。
这些行代码打印出在95%和90%置信度下的临界次品率。

这段代码通过计算样本量和临界值，帮助企业决定在给定的置信度下，如何通过抽样检测来接受或拒绝供应商提供的零配件。

以下是完整版的代码：

大家如果感兴趣的话可以自己运行一下。

python 复制代码

from scipy.stats import norm

# 参数设置
p0 = 0.10  # 标称次品率
confidence_95 = 0.95
confidence_90 = 0.90
e = 0.05  # 抽样误差

# 置信度对应的Z值
z_95 = norm.ppf(1 - (1 - confidence_95) / 2)
z_90 = norm.ppf(1 - (1 - confidence_90) / 2)

# 计算样本量
n_95 = (z_95 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
n_90 = (z_90 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2

print(f"Sample size for 95% confidence level: {n_95:.2f}")
print(f"Sample size for 90% confidence level: {n_90:.2f}")

# 计算临界值
critical_value_95 = p0 + z_95 * (e / ((p0 * (1 - p0)) ** 0.5))
critical_value_90 = p0 + z_90 * (e / ((p0 * (1 - p0)) ** 0.5))

print(f"Critical value for 95% confidence level: {critical_value_95:.4f}")
print(f"Critical value for 90% confidence level: {critical_value_90:.4f}")

第二题：

这段代码是一个使用Python编写的线性规划模型，用于解决一个生产决策问题。它使用了`pulp`库，这是一个流行的线性规划库，可以用来定义问题、决策变量、目标函数和约束条件。以下是代码的详细解释：

python 复制代码

import pulp

这行代码导入了`pulp`库，它是一个用于线性规划的Python库。

python 复制代码

def solve_decision_problem(part1_defect_rate, part2_defect_rate, assembly_defect_rate,
                          part1_cost, part2_cost, assembly_cost,
                          test_cost_part1, test_cost_part2, test_cost_assembly,
                          market_price, replacement_loss, disassembly_cost, reputation_loss):

这行代码定义了一个名为`solve_decision_problem`的函数，它接受一系列参数，这些参数代表生产过程中的各种成本、价格、次品率等。

python 复制代码

    prob = pulp.LpProblem("Production_Decision", pulp.LpMaximize)  # 改为最大化问题

这行代码创建了一个线性规划问题对象`prob`，命名为"Production_Decision"。问题的目标是最大化（`pulp.LpMaximize`），这意味着我们的目标是最大化利润。

python 复制代码

    test_part1 = pulp.LpVariable("test_part1", cat='Binary')
    test_part2 = pulp.LpVariable("test_part2", cat='Binary')
    test_assembly = pulp.LpVariable("test_assembly", cat='Binary')
    disassemble = pulp.LpVariable("disassemble", cat='Binary')

这些行定义了四个决策变量，它们是二进制变量（0或1），用于表示是否执行特定的操作（例如测试零配件1、测试零配件2、测试装配成品、拆解不合格成品）。

python 复制代码

    # 成本计算
    total_cost = (
        part1_cost * (1 - test_part1) * part1_defect_rate +# 零配件1的购买成本（未测试且有缺陷时）
        part2_cost * (1 - test_part2) * part2_defect_rate +#零配件2的购买成本（未测试且有缺陷时）
        assembly_cost * (1 - test_assembly) * assembly_defect_rate +#装配成本（未测试且有缺陷时）
        test_cost_part1 * test_part1 +#零配件1的测试成本
        test_cost_part2 * test_part2 +#零配件2的测试成本
        test_cost_assembly * test_assembly +#装配的测试成本
        replacement_loss * (1 - disassemble) * assembly_defect_rate +# 替换损失（未拆解且有缺陷时）
        disassembly_cost * disassemble * assembly_defect_rate +# 拆解成本（拆解且有缺陷时
        reputation_loss * test_assembly * assembly_defect_rate# 由于装配缺陷导致的声誉损失
    )

这段代码计算了总成本，包括购买成本、检测成本、装配成本、拆解费用和声誉损失。每个成本项都乘以相应的决策变量，以确定在特定决策下的成本。

python 复制代码

    # 收入计算
    total_revenue = market_price * (1 - assembly_defect_rate) * (1 - test_assembly)

这行代码计算了总收入，基于市场销售价格和最终产品的合格数量。

python 复制代码

    # 目标函数：最大化净利润
    prob += total_revenue - total_cost

这行代码设置了目标函数，即最大化总收入减去总成本的差值，也就是最大化利润。

python 复制代码

    prob += test_part1 + test_part2 >= 1, "At_least_one_part_tested"
    prob += disassemble >= test_assembly * assembly_defect_rate, "Disassemble_if_defective"

这些行定义了模型的约束条件，确保至少有一个零配件被测试，并且如果有缺陷的成品被测试出来，则必须拆解。

python 复制代码

    prob.solve()

    print("Status:", pulp.LpStatus[prob.status])
    print("Should test Part 1? ", "Yes" if test_part1.varValue > 0.5 else "No")
    print("Should test Part 2? ", "Yes" if test_part2.varValue > 0.5 else "No")
    print("Should test Assembly? ", "Yes" if test_assembly.varValue > 0.5 else "No")
    print("Should disassemble defective products? ", "Yes" if disassemble.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

solve_decision_problem(0.125, 0.1416, 0.125, 4, 18, 6, 1.8, 2.33, 2.66, 56, 15.33, 5, 10)

调用`pulp`的求解器来求解线性规划问题。

打印求解状态和每个决策变量的结果，告诉我们是否应该执行特定的操作，以及总收入、总成本和净利润的数值。

打印每个决策变量的结果，告诉我们是否应该测试每个零配件。

打印总收入、总成本和净利润的数值。

这行代码调用`solve_decision_problem`函数，并传入具体的参数值来运行模型。

这个模型是一个完整的线性规划模型，用于帮助企业在生产过程中做出最优的决策。

以下是完整的代码：

感兴趣的小伙伴可以自己去运行一下。

python 复制代码

import pulp

def solve_decision_problem(part1_defect_rate, part2_defect_rate, assembly_defect_rate,
                          part1_cost, part2_cost, assembly_cost,
                          test_cost_part1, test_cost_part2, test_cost_assembly,
                          market_price, replacement_loss, disassembly_cost, reputation_loss):
    prob = pulp.LpProblem("Production_Decision", pulp.LpMaximize)  # 改为最大化问题

    test_part1 = pulp.LpVariable("test_part1", cat='Binary')
    test_part2 = pulp.LpVariable("test_part2", cat='Binary')
    test_assembly = pulp.LpVariable("test_assembly", cat='Binary')
    disassemble = pulp.LpVariable("disassemble", cat='Binary')

    # 成本计算
    total_cost = (
        part1_cost * (1 - test_part1) * part1_defect_rate +# 零配件1的购买成本（未测试且有缺陷时）
        part2_cost * (1 - test_part2) * part2_defect_rate +#零配件2的购买成本（未测试且有缺陷时）
        assembly_cost * (1 - test_assembly) * assembly_defect_rate +#装配成本（未测试且有缺陷时）
        test_cost_part1 * test_part1 +#零配件1的测试成本
        test_cost_part2 * test_part2 +#零配件2的测试成本
        test_cost_assembly * test_assembly +#装配的测试成本
        replacement_loss * (1 - disassemble) * assembly_defect_rate +# 替换损失（未拆解且有缺陷时）
        disassembly_cost * disassemble * assembly_defect_rate +# 拆解成本（拆解且有缺陷时
        reputation_loss * test_assembly * assembly_defect_rate# 由于装配缺陷导致的声誉损失
    )

    # 收入计算
    total_revenue = market_price * (1 - assembly_defect_rate) * (1 - test_assembly)

    # 目标函数：最大化净利润
    prob += total_revenue - total_cost

    prob += test_part1 + test_part2 >= 1, "At_least_one_part_tested"
    prob += disassemble >= test_assembly * assembly_defect_rate, "Disassemble_if_defective"

    prob.solve()

    print("Status:", pulp.LpStatus[prob.status])
    print("Should test Part 1? ", "Yes" if test_part1.varValue > 0.5 else "No")
    print("Should test Part 2? ", "Yes" if test_part2.varValue > 0.5 else "No")
    print("Should test Assembly? ", "Yes" if test_assembly.varValue > 0.5 else "No")
    print("Should disassemble defective products? ", "Yes" if disassemble.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

solve_decision_problem(0.125, 0.1416, 0.125, 4, 18, 6, 1.8, 2.33, 2.66, 56, 15.33, 5, 10)

第三题：

这段代码是一个使用Python编写的线性规划模型，旨在解决一个多阶段生产过程的优化问题。它使用了`pulp`库来定义和求解一个线性规划问题，目的是最大化生产过程的利润。以下是代码的详细解释：

python 复制代码

import pulp

这行代码导入了`pulp`库，这是一个用于线性规划的Python库，它提供了定义优化问题、决策变量、目标函数和约束条件的功能

python 复制代码

def solve_multistage_production():
    prob = pulp.LpProblem("Multistage_Production", pulp.LpMaximize)  # 改为最大化利润

这行代码定义了一个名为`solve_multistage_production`的函数，它封装了解决多阶段生产问题的逻辑。

创建了一个名为"Multistage_Production"的线性规划问题对象`prob`，目标是最大化（`pulp.LpMaximize`），这意味着我们的目标是最大化利润。

python 复制代码

    # 示例数据
    num_parts = 8
    defective_rate_part = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]# 零配件次品率
    purchase_price = [2, 8, 12, 2, 8, 12, 8, 12]# 零配件购买单价
    test_cost = [1, 1, 2, 1, 1, 2, 1, 2]# 零配件检测成本
    assembly_cost = [8, 8]# 半成品装配成本，假设有两个半成品
    defective_rate_assembly = [0.1, 0.1]# 半成品次品率
    final_assembly_cost = 10# 最终成品装配成本
    defective_rate_final = 0.1# 最终成品次品率
    market_price = 200# 成品市场售价
    replacement_loss = 40# 调换损失
    disassembly_cost_assembly = [6, 6]# 拆解半成品成本
    disassembly_cost_final = 10 # 拆解最终成品成本

这些行定义了用于模型的参数，包括零配件的数量、次品率、购买单价、检测成本、半成品的装配成本和次品率、最终成品的装配成本和次品率、市场售价、调换损失以及拆解成本。

python 复制代码

    # 决策变量
    test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
    assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
    test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
    produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
    disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
    disassemble_final = pulp.LpVariable("Disassemble_Final", cat='Binary')

这些行定义了模型的决策变量，它们是二进制变量（0或1），用于表示是否执行特定的操作，如测试零配件、组装半成品、测试半成品、生产最终产品、拆解不合格的半成品和最终产品。

python 复制代码

    # 成本计算
    total_cost = (
        sum(purchase_price[i] * test_part[i] * (1 - defective_rate_part[i]) for i in range(num_parts)) +
        sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
        sum(assembly_cost[j] * assemble[j] for j in range(2)) +
        sum(test_cost[j] * test_assembly[j] for j in range(2)) +
        final_assembly_cost * produce_final +
        replacement_loss * (1 - produce_final) +
        sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
        disassembly_cost_final * disassemble_final
    )

这段代码计算了总成本，包括购买成本、检测成本、装配成本、拆解费用和调换损失。每个成本项都乘以相应的决策变量，以确定在特定决策下的成本。

python 复制代码

    # 收益计算
    total_revenue = market_price * (1 - defective_rate_final) * produce_final

这行代码计算了总收入，基于市场销售价格和最终产品的合格数量。

python 复制代码

    # 目标函数：最大化利润
    prob += total_revenue - total_cost

这行代码设置了目标函数，即最大化总收入减去总成本的差值，也就是最大化利润。

python 复制代码

    # 约束条件
    for i in range(num_parts):
        prob += test_part[i] == 1

    for j in range(2):
        prob += assemble[j] <= test_part[j]
        prob += test_assembly[j] <= assemble[j]
        prob += disassemble_assembly[j] >= test_assembly[j] * defective_rate_assembly[j]

    prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
    prob += disassemble_final >= produce_final * defective_rate_final  # 如果最终产品不合格则拆解

这些行定义了模型的约束条件，确保所有零配件都需要检测，只有检测通过的零配件才能用于组装，组装后需要检测半成品，如果半成品不合格，则需要拆解，只有所有半成品检测通过才能生产最终产品，如果最终产品不合格，则需要拆解。

python 复制代码

    prob.solve()

    # 输出结果
    print("Status:", pulp.LpStatus[prob.status])
    for i in range(num_parts):
        print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
        print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
    print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
    print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

solve_multistage_production()

这行代码调用`pulp`的求解器来求解线性规划问题。

这些行打印求解状态和每个决策变量的结果，告诉我们是否应该执行特定的操作，以及总收入、总成本和净利润的数值。

这些行打印每个决策变量的结果，告诉我们是否应该测试每个零配件。

这些行打印总收入、总成本和净利润的数值。

这行代码调用`solve_multistage_production`函数来运行模型。

这个模型是一个完整的线性规划模型，用于帮助企业在多阶段生产过程中做出最优的决策。

以下就是完整的代码：

python 复制代码

import pulp

def solve_multistage_production():
    prob = pulp.LpProblem("Multistage_Production", pulp.LpMaximize)  # 改为最大化利润

    # 示例数据
    num_parts = 8
    defective_rate_part = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]# 零配件次品率
    purchase_price = [2, 8, 12, 2, 8, 12, 8, 12]# 零配件购买单价
    test_cost = [1, 1, 2, 1, 1, 2, 1, 2]# 零配件检测成本
    assembly_cost = [8, 8]# 半成品装配成本，假设有两个半成品
    defective_rate_assembly = [0.1, 0.1]# 半成品次品率
    final_assembly_cost = 10# 最终成品装配成本
    defective_rate_final = 0.1# 最终成品次品率
    market_price = 200# 成品市场售价
    replacement_loss = 40# 调换损失
    disassembly_cost_assembly = [6, 6]# 拆解半成品成本
    disassembly_cost_final = 10 # 拆解最终成品成本

    # 决策变量
    test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
    assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
    test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
    produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
    disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
    disassemble_final = pulp.LpVariable("Disassemble_Final", cat='Binary')

    # 成本计算
    total_cost = (
        sum(purchase_price[i] * test_part[i] * (1 - defective_rate_part[i]) for i in range(num_parts)) +
        sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
        sum(assembly_cost[j] * assemble[j] for j in range(2)) +
        sum(test_cost[j] * test_assembly[j] for j in range(2)) +
        final_assembly_cost * produce_final +
        replacement_loss * (1 - produce_final) +
        sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
        disassembly_cost_final * disassemble_final
    )

    # 收益计算
    total_revenue = market_price * (1 - defective_rate_final) * produce_final

    # 目标函数：最大化利润
    prob += total_revenue - total_cost

    # 约束条件
    for i in range(num_parts):
        prob += test_part[i] == 1

    for j in range(2):
        prob += assemble[j] <= test_part[j]
        prob += test_assembly[j] <= assemble[j]
        prob += disassemble_assembly[j] >= test_assembly[j] * defective_rate_assembly[j]

    prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
    prob += disassemble_final >= produce_final * defective_rate_final  # 如果最终产品不合格则拆解

    prob.solve()

    # 输出结果
    print("Status:", pulp.LpStatus[prob.status])
    for i in range(num_parts):
        print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
        print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
    print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
    print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

solve_multistage_production()

第四题：

python 复制代码

import pulp
import numpy as np

这两行代码导入了所需的Python库。`pulp` 是一个线性规划库，用于定义和解决优化问题。`numpy` 是一个用于数值计算的库，提供了大量的数学函数和操作。

python 复制代码

def simulate_sampling_error(true_rate, sample_size, num_samples=1000):

定义了一个名为 `simulate_sampling_error` 的函数，该函数用于模拟抽样误差。

python 复制代码

    """模拟抽样误差，返回抽样得到的次品率估计值的平均值"""
    np.random.seed(0)  # 确保可重复性

这是一个多行字符串，作为函数的文档字符串，解释了函数的作用。

设置随机数生成器的种子，以确保每次运行代码时生成的随机数相同，从而保证结果的可重复性。

python 复制代码

    estimates = [np.random.binomial(sample_size, true_rate) / sample_size for _ in range(num_samples)]

创建一个列表，其中包含根据二项分布模拟的次品率估计值。对于每个样本，都进行 `num_samples` 次模拟。

python 复制代码

    return np.mean(estimates)

返回模拟次品率估计值的平均值。

python 复制代码

def solve_decision_problem_with_sampling_error():

定义了一个名为 `solve_decision_problem_with_sampling_error` 的函数，用于解决生产决策问题。

python 复制代码

    prob = pulp.LpProblem("Production_Decision_With_Error", pulp.LpMaximize)

创建一个线性规划问题对象 `prob`，命名为 "Production_Decision_With_Error"，并设置为最大化问题。

python 复制代码

    # 示例数据
    num_parts = 8
    sample_size = 100  # 假设抽样大小
    true_defective_rates = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]  # 真实次品率
    estimated_defective_rates = [simulate_sampling_error(rate, sample_size) for rate in true_defective_rates]

设置一些示例数据，包括零配件的数量、抽样大小、真实次品率，并使用 `simulate_sampling_error` 函数估计次品率。

python 复制代码

    # 其他参数
    purchase_price = [2, 8, 12, 2, 8, 12, 8, 12]  # 零配件购买单价
    test_cost = [1, 1, 2, 1, 1, 2, 1, 2]  # 零配件检测成本
    assembly_cost = [8, 8]  # 半成品装配成本，假设有两个半成品
    test_cost_assembly = [4, 4]  # 半成品检测成本
    disassembly_cost_assembly = [6, 6]  # 半成品拆解成本
    final_assembly_cost = 10  # 最终成品装配成本
    market_price = 200  # 成品市场售价
    replacement_loss = 40  # 调换损失
    disassembly_cost_final = 10  # 拆解最终成品成本

定义了其他与生产过程相关的参数，如购买单价、检测成本、装配成本、市场售价、调换损失和拆解成本。

python 复制代码

    # 决策变量
    test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
    assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
    test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
    produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
    disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
    disassemble_final = pulp.LpVariable("Disassemble_Final", cat='Binary')

定义了一组决策变量，用于表示是否进行检测、组装、生产最终产品和拆解等操作。

python 复制代码

    # 成本计算
    total_cost = (
        sum(purchase_price[i] * test_part[i] * (1 - estimated_defective_rates[i]) for i in range(num_parts)) +
        sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
        sum(assembly_cost[j] * assemble[j] for j in range(2)) +
        sum(test_cost_assembly[j] * test_assembly[j] for j in range(2)) +
        final_assembly_cost * produce_final +
        replacement_loss * (1 - produce_final) +
        sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
        disassembly_cost_final * disassemble_final
)

计算总成本，包括购买成本、检测成本、装配成本、调换损失和拆解成本。

python 复制代码

    # 收益计算
    total_revenue = market_price * (1 - max(estimated_defective_rates)) * produce_final

计算总收入，即生产并销售最终产品的收入。

python 复制代码

    # 目标函数：最大化利润
    prob += total_revenue - total_cost

设置目标函数为最大化利润，即总收入减去总成本。

python 复制代码

    # 约束条件
    for i in range(num_parts):
        prob += test_part[i] == 1  # 假设所有零配件都需要检测

添加约束条件，假设所有零配件都需要检测。

python 复制代码

    for j in range(2):
        prob += assemble[j] <= test_part[j]  # 只有检测通过的零配件才能用于组装
        prob += test_assembly[j] <= assemble[j]  # 组装后需要检测
        prob += disassemble_assembly[j] >= test_assembly[j] * estimated_defective_rates[j]  # 如果半成品不合格则拆解

添加其他约束条件，包括零配件检测、半成品组装和检测，以及不合格半成品的拆解。

python 复制代码

    prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
    prob += disassemble_final >= produce_final * max(estimated_defective_rates)  # 如果最终产品不合格则拆解

添加最终产品的生产和拆解约束条件。

python 复制代码

    prob.solve()

解决定义好的线性规划问题。

python 复制代码

    # 输出结果
    print("Status:", pulp.LpStatus[prob.status])
    for i in range(num_parts):
        print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
        print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
    print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
    print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

输出问题的解决状态、每个决策变量的结果、总收入、总成本和净利润。

请注意，代码中的一些约束条件可能需要根据实际情况进行调整，以确保它们正确地反映了生产过程中的逻辑关系。

以下是完整的代码：

python 复制代码

import pulp
import numpy as np

def simulate_sampling_error(true_rate, sample_size, num_samples=1000):
    """模拟抽样误差，返回抽样得到的次品率估计值的平均值"""
    np.random.seed(0)  # 确保可重复性
    estimates = [np.random.binomial(sample_size, true_rate) / sample_size for _ in range(num_samples)]
    return np.mean(estimates)

def solve_decision_problem_with_sampling_error():
    prob = pulp.LpProblem("Production_Decision_With_Error", pulp.LpMaximize)

    # 示例数据
    num_parts = 8
    sample_size = 100  # 假设抽样大小
    true_defective_rates = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]  # 真实次品率
    estimated_defective_rates = [simulate_sampling_error(rate, sample_size) for rate in true_defective_rates]

    # 其他参数
    purchase_price = [2, 8, 12, 2, 8, 12, 8, 12]  # 零配件购买单价
    test_cost = [1, 1, 2, 1, 1, 2, 1, 2]  # 零配件检测成本
    assembly_cost = [8, 8]  # 半成品装配成本，假设有两个半成品
    test_cost_assembly = [4, 4]  # 半成品检测成本
    disassembly_cost_assembly = [6, 6]  # 半成品拆解成本
    final_assembly_cost = 10  # 最终成品装配成本
    market_price = 200  # 成品市场售价
    replacement_loss = 40  # 调换损失
    disassembly_cost_final = 10  # 拆解最终成品成本

    # 决策变量
    test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
    assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
    test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
    produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
    disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
    disassemble_final = pulp.LpVariable("Disassemble_Final", cat='Binary')

    # 成本计算
    total_cost = (
        sum(purchase_price[i] * test_part[i] * (1 - estimated_defective_rates[i]) for i in range(num_parts)) +
        sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
        sum(assembly_cost[j] * assemble[j] for j in range(2)) +
        sum(test_cost_assembly[j] * test_assembly[j] for j in range(2)) +
        final_assembly_cost * produce_final +
        replacement_loss * (1 - produce_final) +
        sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
        disassembly_cost_final * disassemble_final
    )

    # 收益计算
    total_revenue = market_price * (1 - max(estimated_defective_rates)) * produce_final

    # 目标函数：最大化利润
    prob += total_revenue - total_cost

    # 约束条件
    for i in range(num_parts):
        prob += test_part[i] == 1  # 假设所有零配件都需要检测

    for j in range(2):
        prob += assemble[j] <= test_part[j]  # 只有检测通过的零配件才能用于组装
        prob += test_assembly[j] <= assemble[j]  # 组装后需要检测
        prob += disassemble_assembly[j] >= test_assembly[j] * estimated_defective_rates[j]  # 如果半成品不合格则拆解

    prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
    prob += disassemble_final >= produce_final * max(estimated_defective_rates)  # 如果最终产品不合格则拆解

    prob.solve()

    # 输出结果
    print("Status:", pulp.LpStatus[prob.status])
    for i in range(num_parts):
        print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
        print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
    print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
    for j in range(2):
        print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
    print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
    print("Total Revenue: ", pulp.value(total_revenue))
    print("Total Cost: ", pulp.value(total_cost))
    print("Net Profit: ", pulp.value(total_revenue - total_cost))

solve_decision_problem_with_sampling_error()

结语：

太久没有更新了实在不好意思了，之后我会持续更新的这次的数学建模比赛是我们团队一起完成的，这是我们最后的论文和代码。其实对于最后的结果我们也没有什么太大的把握，希望看到这篇文章的大神们可以给我们一些建议和改进的方法我们会虚心接受和认真改正的，最后也希望大家多多关注下小编。文章有任何问题和错误欢迎大家的斧正。