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

目次

一、弁言
1. 1竞赛背景介绍
1.1.1数学建模竞赛概述
1.1.2生产过程决策题目在竞赛中的告急性
1.2 解题前预备
1.2.2 工具与资源预备
1.2.3 心态调整与策略规划
二、题目理解与分析
三、模型构建与求解
3.1 模型选择与设计
3.1.1 根据题目特性选择合适的数学模型类型
3.1.2 设计模型框架，定义变量、参数和方程
3.2 模型构建
3.2.1 构建目标函数，反映生产决策的优化目标
3.2.2 将所有束缚条件转化为模型中的束缚方程
3.2.3 检查模型的有用性和合理性
3.3 模型求解
3.3.1 选择合适的求解算法或工具
3.3.2 举行模型求解，获取初步结果
3.3.3 对结果举行初步分析，检查是否符合预期
四、结果验证与优化
4.1结果验证
4.1.1 实际情况或知识对比验证
4.1.2 分析模型假设的合理性
4.2模型优化
4.2.1 调整模型参数或假设
4.2.2 尝试不同的求解算法或模型布局
4.2.3 评估不同优化方案的优缺点
五、反思与提升
5.1解题过程反思
5.1.2分析团队互助与个人体现，辨认不敷之处
5.2知识与本领提升
5.2.1 总结所用到的数学建模知识和方法
5.2.2 思考如何将这些知识和方法应用到其他领域或题目中
参考文献
六、解题思路
题目1：
解题思路：
方法：
题目2：生产过程决策
解题思路：
方法：
题目3：
解题思路：
方法：
题目4：考虑抽样误差的决策
解题思路：
方法：
通用步骤
七、解题代码
第一题：
第二题：
第三题：
结语：

---

一、弁言

1. 1竞赛背景介绍

1.1.1数学建模竞赛概述

数学建模竞赛，作为一项集知识性、创新性与实践性于一体的国际性赛事，旨在培养学生运用数学理论与方法办理实际题目的本领。它要求参赛者针对现实生存中的复杂题目，通过深入的分析、抽象与建模，最终提出科学合理的办理方案。数学建模竞赛不仅磨练了学生的数学基础，更告急的是锻炼了他们的逻辑思维本领、团队互助精神以及创新本领。在这个过程中，学生需要将抽象的数学理论与具体的应用场景相结合，创造出既有理论深度又具实用价值的模型。
在数学建模竞赛中，题目类型多样，涵盖自然科学、社会科学、工程技术等多个领域。其中，生产过程中的决策题目因其贴近实际、复杂多变而备受关注。这类题目往往涉及到资源分配、生产调度、成本控制等多个方面，要求参赛者可以大概全面把握题目的焦点，准确辨认关键变量，并设计出高效、可靠的数学模型举行求解。
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代码用于计算在给定置信度下的抽样检测方案，特别是确定所需的最小样本量和临界次品率。这些计算对于质量控制和抽样查验非常告急，可以帮助企业决定是否接受供应商提供的零配件。以下是代码的具体解释：

1. from scipy.stats import norm

复制代码

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

1. # 参数设置
2. p0 = 0.10  # 标称次品率
3. confidence_95 = 0.95
4. confidence_90 = 0.90
5. e = 0.05  # 抽样误差

复制代码

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

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

复制代码

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

1. # 计算样本量
2. n_95 = (z_95 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
3. n_90 = (z_90 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
5. print(f"Sample size for 95% confidence level: {n_95:.2f}")
6. print(f"Sample size for 90% confidence level: {n_90:.2f}")

复制代码

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

1. # 计算临界值
2. critical_value_95 = p0 + z_95 * (e / ((p0 * (1 - p0)) ** 0.5))
3. critical_value_90 = p0 + z_90 * (e / ((p0 * (1 - p0)) ** 0.5))
5. print(f"Critical value for 95% confidence level: {critical_value_95:.4f}")
6. print(f"Critical value for 90% confidence level: {critical_value_90:.4f}")

复制代码

- 这些公式用于计算在给定置信度下的临界次品率。
- `critical_value_95` 和 `critical_value_90`: 分别是95%和90%置信度下的临界值。
- 这些行代码打印出在95%和90%置信度下的临界次品率。
这段代码通过计算样本量和临界值，帮助企业决定在给定的置信度下，如何通过抽样检测来接受或拒绝供应商提供的零配件。
以下是完整版的代码：
各人如果感兴趣的话可以自己运行一下。

1. from scipy.stats import norm# 参数设置
2. p0 = 0.10  # 标称次品率
3. confidence_95 = 0.95
4. confidence_90 = 0.90
5. e = 0.05  # 抽样误差# 置信度对应的Z值
6. z_95 = norm.ppf(1 - (1 - confidence_95) / 2)
7. z_90 = norm.ppf(1 - (1 - confidence_90) / 2)# 计算样本量
8. n_95 = (z_95 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
9. n_90 = (z_90 * ((p0 * (1 - p0)) ** 0.5)) ** 2 / e ** 2
11. print(f"Sample size for 95% confidence level: {n_95:.2f}")
12. print(f"Sample size for 90% confidence level: {n_90:.2f}")# 计算临界值
13. critical_value_95 = p0 + z_95 * (e / ((p0 * (1 - p0)) ** 0.5))
14. critical_value_90 = p0 + z_90 * (e / ((p0 * (1 - p0)) ** 0.5))
16. print(f"Critical value for 95% confidence level: {critical_value_95:.4f}")
17. print(f"Critical value for 90% confidence level: {critical_value_90:.4f}")

复制代码

第二题：

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

1. import pulp

复制代码

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

1. def solve_decision_problem(part1_defect_rate, part2_defect_rate, assembly_defect_rate,
2.                           part1_cost, part2_cost, assembly_cost,
3.                           test_cost_part1, test_cost_part2, test_cost_assembly,
4.                           market_price, replacement_loss, disassembly_cost, reputation_loss):

复制代码

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

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

复制代码

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

1.     test_part1 = pulp.LpVariable("test_part1", cat='Binary')
2.     test_part2 = pulp.LpVariable("test_part2", cat='Binary')
3.     test_assembly = pulp.LpVariable("test_assembly", cat='Binary')
4.     disassemble = pulp.LpVariable("disassemble", cat='Binary')

复制代码

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

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

复制代码

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

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

复制代码

这行代码计算了总收入，基于市场贩卖代价和最终产物的合格数目。

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

复制代码

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

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

复制代码

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

2.     prob.solve()
4.     print("Status:", pulp.LpStatus[prob.status])
5.     print("Should test Part 1? ", "Yes" if test_part1.varValue > 0.5 else "No")
6.     print("Should test Part 2? ", "Yes" if test_part2.varValue > 0.5 else "No")
7.     print("Should test Assembly? ", "Yes" if test_assembly.varValue > 0.5 else "No")
8.     print("Should disassemble defective products? ", "Yes" if disassemble.varValue > 0.5 else "No")
9.     print("Total Revenue: ", pulp.value(total_revenue))
10.     print("Total Cost: ", pulp.value(total_cost))
11.     print("Net Profit: ", pulp.value(total_revenue - total_cost))
13. 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`函数，并传入具体的参数值来运行模型。
这个模型是一个完整的线性规划模型，用于帮助企业在生产过程中做出最优的决策。
以下是完整的代码：
感兴趣的小同伴可以自己去运行一下。

1. import pulpdef solve_decision_problem(part1_defect_rate, part2_defect_rate, assembly_defect_rate,
2.                           part1_cost, part2_cost, assembly_cost,
3.                           test_cost_part1, test_cost_part2, test_cost_assembly,
4.                           market_price, replacement_loss, disassembly_cost, reputation_loss):    prob = pulp.LpProblem("Production_Decision", pulp.LpMaximize)  # 改为最大化问题    test_part1 = pulp.LpVariable("test_part1", cat='Binary')
5.     test_part2 = pulp.LpVariable("test_part2", cat='Binary')
6.     test_assembly = pulp.LpVariable("test_assembly", cat='Binary')
7.     disassemble = pulp.LpVariable("disassemble", cat='Binary')    # 成本计算
8.     total_cost = (
9.         part1_cost * (1 - test_part1) * part1_defect_rate +# 零配件1的购买成本（未测试且有缺陷时）
10.         part2_cost * (1 - test_part2) * part2_defect_rate +#零配件2的购买成本（未测试且有缺陷时）
11.         assembly_cost * (1 - test_assembly) * assembly_defect_rate +#装配成本（未测试且有缺陷时）
12.         test_cost_part1 * test_part1 +#零配件1的测试成本
13.         test_cost_part2 * test_part2 +#零配件2的测试成本
14.         test_cost_assembly * test_assembly +#装配的测试成本
15.         replacement_loss * (1 - disassemble) * assembly_defect_rate +# 替换损失（未拆解且有缺陷时）
16.         disassembly_cost * disassemble * assembly_defect_rate +# 拆解成本（拆解且有缺陷时
17.         reputation_loss * test_assembly * assembly_defect_rate# 由于装配缺陷导致的声誉损失
18.     )    # 收入计算
19.     total_revenue = market_price * (1 - assembly_defect_rate) * (1 - test_assembly)
20.     # 目标函数：最大化净利润
21.     prob += total_revenue - total_cost    prob += test_part1 + test_part2 >= 1, "At_least_one_part_tested"
22.     prob += disassemble >= test_assembly * assembly_defect_rate, "Disassemble_if_defective"
23.     prob.solve()
25.     print("Status:", pulp.LpStatus[prob.status])
26.     print("Should test Part 1? ", "Yes" if test_part1.varValue > 0.5 else "No")
27.     print("Should test Part 2? ", "Yes" if test_part2.varValue > 0.5 else "No")
28.     print("Should test Assembly? ", "Yes" if test_assembly.varValue > 0.5 else "No")
29.     print("Should disassemble defective products? ", "Yes" if disassemble.varValue > 0.5 else "No")
30.     print("Total Revenue: ", pulp.value(total_revenue))
31.     print("Total Cost: ", pulp.value(total_cost))
32.     print("Net Profit: ", pulp.value(total_revenue - total_cost))
34. 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`库来定义和求解一个线性规划题目，目的是最大化生产过程的利润。以下是代码的具体解释：

1. import pulp

复制代码

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

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

复制代码

这行代码定义了一个名为`solve_multistage_production`的函数，它封装了办理多阶段生产题目的逻辑。
创建了一个名为"Multistage_Production"的线性规划题目对象`prob`，目标是最大化（`pulp.LpMaximize`），这意味着我们的目标是最大化利润。

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

复制代码

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

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

复制代码

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

1.     # 成本计算
2.     total_cost = (
3.         sum(purchase_price[i] * test_part[i] * (1 - defective_rate_part[i]) for i in range(num_parts)) +
4.         sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
5.         sum(assembly_cost[j] * assemble[j] for j in range(2)) +
6.         sum(test_cost[j] * test_assembly[j] for j in range(2)) +
7.         final_assembly_cost * produce_final +
8.         replacement_loss * (1 - produce_final) +
9.         sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
10.         disassembly_cost_final * disassemble_final
11.     )

复制代码

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

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

复制代码

这行代码计算了总收入，基于市场贩卖代价和最终产物的合格数目。

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

复制代码

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

1.     # 约束条件
2.     for i in range(num_parts):
3.         prob += test_part[i] == 1
5.     for j in range(2):
6.         prob += assemble[j] <= test_part[j]
7.         prob += test_assembly[j] <= assemble[j]
8.         prob += disassemble_assembly[j] >= test_assembly[j] * defective_rate_assembly[j]
10.     prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
11.     prob += disassemble_final >= produce_final * defective_rate_final  # 如果最终产品不合格则拆解

复制代码

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

1.     prob.solve()
3.     # 输出结果
4.     print("Status:", pulp.LpStatus[prob.status])
5.     for i in range(num_parts):
6.         print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
7.     for j in range(2):
8.         print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
9.         print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
10.     print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
11.     for j in range(2):
12.         print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
13.     print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
14.     print("Total Revenue: ", pulp.value(total_revenue))
15.     print("Total Cost: ", pulp.value(total_cost))
16.     print("Net Profit: ", pulp.value(total_revenue - total_cost))
18. solve_multistage_production()

复制代码

这行代码调用`pulp`的求解器来求解线性规划题目。
这些行打印求解状态和每个决策变量的结果，告诉我们是否应该执行特定的操作，以及总收入、总成本和净利润的数值。
这些行打印每个决策变量的结果，告诉我们是否应该测试每个零配件。
这些行打印总收入、总成本和净利润的数值。
这行代码调用`solve_multistage_production`函数来运行模型。
这个模型是一个完整的线性规划模型，用于帮助企业在多阶段生产过程中做出最优的决策。
以下就是完整的代码：

1. import pulpdef solve_multistage_production():
2.     prob = pulp.LpProblem("Multistage_Production", pulp.LpMaximize)  # 改为最大化利润    # 示例数据
3.     num_parts = 8
4.     defective_rate_part = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]# 零配件次品率
5.     purchase_price = [2, 8, 12, 2, 8, 12, 8, 12]# 零配件购买单价
6.     test_cost = [1, 1, 2, 1, 1, 2, 1, 2]# 零配件检测成本
7.     assembly_cost = [8, 8]# 半成品装配成本，假设有两个半成品
8.     defective_rate_assembly = [0.1, 0.1]# 半成品次品率
9.     final_assembly_cost = 10# 最终成品装配成本
10.     defective_rate_final = 0.1# 最终成品次品率
11.     market_price = 200# 成品市场售价
12.     replacement_loss = 40# 调换损失
13.     disassembly_cost_assembly = [6, 6]# 拆解半成品成本
14.     disassembly_cost_final = 10 # 拆解最终成品成本    # 决策变量
15.     test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
16.     assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
17.     test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
18.     produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
19.     disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
20.     disassemble_final = pulp.LpVariable("Disassemble_Final", cat='Binary')    # 成本计算
21.     total_cost = (
22.         sum(purchase_price[i] * test_part[i] * (1 - defective_rate_part[i]) for i in range(num_parts)) +
23.         sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
24.         sum(assembly_cost[j] * assemble[j] for j in range(2)) +
25.         sum(test_cost[j] * test_assembly[j] for j in range(2)) +
26.         final_assembly_cost * produce_final +
27.         replacement_loss * (1 - produce_final) +
28.         sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
29.         disassembly_cost_final * disassemble_final
30.     )    # 收益计算
31.     total_revenue = market_price * (1 - defective_rate_final) * produce_final    # 目标函数：最大化利润
32.     prob += total_revenue - total_cost    # 约束条件
33.     for i in range(num_parts):
34.         prob += test_part[i] == 1
36.     for j in range(2):
37.         prob += assemble[j] <= test_part[j]
38.         prob += test_assembly[j] <= assemble[j]
39.         prob += disassemble_assembly[j] >= test_assembly[j] * defective_rate_assembly[j]
41.     prob += produce_final <= sum(test_assembly)  # 只有所有半成品检测通过才能生产最终产品
42.     prob += disassemble_final >= produce_final * defective_rate_final  # 如果最终产品不合格则拆解    prob.solve()
44.     # 输出结果
45.     print("Status:", pulp.LpStatus[prob.status])
46.     for i in range(num_parts):
47.         print(f"Should test Part {i+1}? ", "Yes" if test_part[i].varValue > 0.5 else "No")
48.     for j in range(2):
49.         print(f"Should assemble Part {j+1}? ", "Yes" if assemble[j].varValue > 0.5 else "No")
50.         print(f"Should test Assembly {j+1}? ", "Yes" if test_assembly[j].varValue > 0.5 else "No")
51.     print("Should produce final product? ", "Yes" if produce_final.varValue > 0.5 else "No")
52.     for j in range(2):
53.         print(f"Should disassemble Assembly {j+1}? ", "Yes" if disassemble_assembly[j].varValue > 0.5 else "No")
54.     print("Should disassemble final product? ", "Yes" if disassemble_final.varValue > 0.5 else "No")
55.     print("Total Revenue: ", pulp.value(total_revenue))
56.     print("Total Cost: ", pulp.value(total_cost))
57.     print("Net Profit: ", pulp.value(total_revenue - total_cost))
59. solve_multistage_production()

复制代码

第四题：

1. import pulp
2. import numpy as np

复制代码

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

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

复制代码

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

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

复制代码

这是一个多行字符串，作为函数的文档字符串，解释了函数的作用。
设置随机数生成器的种子，以确保每次运行代码时生成的随机数雷同，从而保证结果的可重复性。

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

复制代码

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

1.     return np.mean(estimates)

复制代码

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

1. def solve_decision_problem_with_sampling_error():

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

1.     # 成本计算
2.     total_cost = (
3.         sum(purchase_price[i] * test_part[i] * (1 - estimated_defective_rates[i]) for i in range(num_parts)) +
4.         sum(test_cost[i] * test_part[i] for i in range(num_parts)) +
5.         sum(assembly_cost[j] * assemble[j] for j in range(2)) +
6.         sum(test_cost_assembly[j] * test_assembly[j] for j in range(2)) +
7.         final_assembly_cost * produce_final +
8.         replacement_loss * (1 - produce_final) +
9.         sum(disassembly_cost_assembly[j] * disassemble_assembly[j] for j in range(2)) +
10.         disassembly_cost_final * disassemble_final
11. )

复制代码

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

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

复制代码

计算总收入，即生产并贩卖最终产物的收入。

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

复制代码

添加最终产物的生产和拆解束缚条件。

1.     prob.solve()

复制代码

办理定义好的线性规划题目。

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

复制代码

输出题目的办理状态、每个决策变量的结果、总收入、总成本和净利润。
请注意，代码中的一些束缚条件大概需要根据实际情况举行调整，以确保它们正确地反映了生产过程中的逻辑关系。

以下是完整的代码：

1. import pulp
2. import numpy as npdef 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  # 拆解最终成品成本    # 决策变量
3.     test_part = pulp.LpVariable.dicts("Test_Part", range(num_parts), cat='Binary')
4.     assemble = pulp.LpVariable.dicts("Assemble", range(2), cat='Binary')
5.     test_assembly = pulp.LpVariable.dicts("Test_Assembly", range(2), cat='Binary')
6.     produce_final = pulp.LpVariable("Produce_Final", cat='Binary')
7.     disassemble_assembly = pulp.LpVariable.dicts("Disassemble_Assembly", range(2), cat='Binary')
8.     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    # 目标函数：最大化利润
9.     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()

复制代码

结语：

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。