爱吱声

标题: 求教：一道数学题的解法。 [打印本页]
作者: 绿葱头    时间: 2017-7-4 08:59
标题: 求教：一道数学题的解法。
这道题是这样的：
　根据历史统计情况，某超市某种面包的日销量为100、110、120、130、140个的概率相同，每个面包的进价为4元，销售价为5元，但如果当天没有卖完，剩余的面包次日将以每个3元处理。为取得最大利润，该超市每天应进货这种面包（）个。
　　A.110
　　B.120
　　C.130
　　D.140

我的想法是第一天卖不完的会影响第二天的销售，比如每天进货110个，第一天假设卖掉了100个，第二天假如能卖120个，那第二天全部能卖掉，挣110-10元。如果第二天能卖110个，那么第二天还会剩10个，影响第三天的收入……
因此我简单计算了下，蒙了A，但我不知道如何用数学描述，书到用时方恨少：（。
网上有种答案感觉是基于不影响第二天的销售数量计算的（见下图）。
[attach]71552[/attach]
我觉得不对，求教各位，这道题应该怎么算？
作者: code_abc    时间: 2017-7-4 09:44
是否还要考虑上一天剩余的对今天的影响。比如进110个的策略，销售了110个，但其中10个是上一天剩下的，结果还是有10个剩下。而当天的利润只有90。
作者: ccqi    时间: 2017-7-4 10:19
本帖最后由 ccqi 于 2017-7-4 10:23 编辑

如果上面那个二维表思路是对的，那么用119和121分别试了一下，确实是120最高。
作者: tianxq888    时间: 2017-7-4 11:07
对称选中间，想都不用想
作者: loy_20002000    时间: 2017-7-4 11:21
本帖最后由 loy_20002000 于 2017-7-4 11:24 编辑

用最傻瓜的办法解决吧。

100、110、120、130、140个的概率相同，所以单个事件发生的概率为20%。那么期望E(X)=100*20%+110*20%+120*20%+130*20%+140*20%=120。再根据弱大数定律，销售均值=120。

进货量大于均值，长时间销售的情况下供大于求；进货量小于均值，长时间销售的情况下一定求大于供。两者的亏损在概率上是相同的，都是每个面包亏损1元（需求没有得到满足也是亏损）。把进货量控制在均值附近是亏损最小的做法，即120附近。

分析这类问题从全局看比较好解决，从单个事件分析会十分复杂，并且没有普遍性。个人观点。
作者: 绿葱头    时间: 2017-7-4 13:53
loy_20002000 发表于 2017-7-4 09:21
用最傻瓜的办法解决吧。

100、110、120、130、140个的概率相同，所以单个事件发生的概率为20%。那么期望E( ...

对“需求没有得到满足也是亏损”这句不解，我刚写了程序用随机数模拟了下，被结果吓到了，如果按照前一天没有卖出的面包算入第二天的销量的话，120就会亏损，我看下自己的程序有没有写错，有时间了弄个js版本大家讨论下。
作者: 牛腰    时间: 2017-7-4 15:35
答案应该是A。

假设你每天进货x，前一天剩面包y，当天的总销售量（应该是市场需求）是z，你当天的利润是MIN(x，z–y) – y。如果当天的市场需求大于面包供给（当天进货量加上前一天的剩余），多余的需求对你的利润没有帮助。但是如果面包供给大于当天的市场需求，多余的供给会减少你下一天的利润。因为这个不对称性质，当天进货的平均面包销售量（能赚钱的那部分）肯定小于平均市场需求。如果连续计算的天数是无穷，那么只要平均当天面包销售量小于平均市场需求，总利润就是负无穷。

在4个选择里B、C、D都大于或等于市场需求，它们的利润都是负无穷。所以A是唯一可能的选择。
作者: loy_20002000    时间: 2017-7-4 17:22
绿葱头 发表于 2017-7-4 13:53
对“需求没有得到满足也是亏损”这句不解，我刚写了程序用随机数模拟了下，被结果吓到了，如果按照前一天 ...

“需求没有得到满足也是亏损”我的意思是这样的，举例子说明。假设进货为100个面包，而客户需求是120，由于每个面包赚1元，少卖20个所以亏损20元。同理的，进货140个面包，而客户需求是120，由于只能降价处理，所以多出来的20个面包亏损20元。

“如果按照前一天没有卖出的面包算入第二天的销量的话，120就会亏损”对于这个问题我是这么看的，不妨分情况讨论。

1.如何看待亏损。如果降价就是亏损，那么只有100这个选项不会亏损。但题意显示80%的情况下消费者需求都得不到满足，这也是一种亏损。

2.我为何说亏损，而不是盈利最大化。这涉及到概率或统计中的局限性，我的水平目前还无法整理成完整的思路。

3.盈利的分析。进货为120，根据题意60%的情况下是这个销量（120、130、140的消费者需求量都是销售总计120个面包），20%的情况是100,20%的情况是110。

E(X)=120*60%+80*20%+100*20%=72+16+20=108

这与主楼图表的计算思路类似，当选择120的情况下盈利最大化。

4.概率计算的局限性。你的困惑主要集中在这里，由于面包是不可长期保存的商品，如果大量滞销则损失不会是1元，而是成本4元。概率计算都遵循大样本原则，对小样本不适用，这里举例说明。假设进货是100个面包，有可能连续半个月出现140个面包的旺盛需求，这里每天损失40元的盈利。假设进货为120个，也有可能连续半个月只能卖出100个并且消费者优先选择新鲜的面包，盈利仅仅为20元，亏损高达80元。

由此可以把题目重新改造以符合实际情况。

根据历史统计情况，某超市某种面包的日销量为100、110、120、130、140个的概率相同，每个面包的进价为4元，销售价为5元，但如果当天没有卖完，剩余的面包次日将以每个3元处理。面包在第三个销售日没有卖完则做报废处理。为取得最大利润，该超市每天应进货这种面包（）

这里还没有完。消费者选择新鲜面包或降价面包的概率是多少，这也是需要考虑的问题。我们不妨假设80%消费者选择新鲜面包，20%选择降价处理的面包，如果新鲜面包销售完消费者选择降价面包。

我设计了几种方案，没有一个可以解决我修改过的这个问题。考虑了近俩钟头，引入保质期就变得好复杂，这就先按下吧。

5.随机数的问题。计算机都是伪随机，所以编程验证会有一些麻烦。假如不考虑面包保质期的问题，并且有真随机，最恰当解是120个。你可以试着分5种情况编程进行比对，不能只考虑120这个情况。
作者: loy_20002000    时间: 2017-7-4 18:21
牛腰 发表于 2017-7-4 15:35
答案应该是A。

假设你每天进货x，前一天剩面包y，当天的总销售量（应该是市场需求）是z，你当天的利润是MI ...

你这个思路是错误的。利润=新鲜面包销售量 - 降价面包销售量。降价面包销售量做到最小并不能保证利润最大化，因为牺牲了新鲜面包销售量。120的情况下仅有40%的可能消费者需求得不到满足，而110却有60%的可能消费者需求得不到满足。

你的意思或许是指当天面包剩余会挤占下一天新鲜面包的消费量。如第一天120的进货，销售100则剩余20。第二天假如是120的销售量则利润很可能不是120，如销售了100个新鲜面包，20个降价的，那么利润是80。不管怎么理解，这道题的实质是概率计算。算一下期望就知道110这个选项小于120。

作者: 老马丁    时间: 2017-7-4 20:17
题目要改一下，每天销售新鲜面包的概率是---------------。 不然这个问题非常复杂，还得假设消费者面对新鲜的5块钱面包和不新鲜的3块钱面包的选择。以及，卖家面对过期两天的面包如何处理（销毁还是继续降价）。 否则，第一天剩下的面包可能到第三天还没卖完。

作者: 牛腰    时间: 2017-7-4 20:55
loy_20002000 发表于 2017-7-4 18:21
你这个思路是错误的。利润=新鲜面包销售量 - 降价面包销售量。降价面包销售量做到最小并不能保证利润最大 ...

这道题问的不是一天的期望值，而是连续多天（接近无穷天）的总利润。如果面包总量小于当天的市场需求，没有被满足的需求量不会增加第二天的需求量。所以市场需求量平均120，实际上能卖出的面包数量期待值小于120。这样积累下来总利润就是负无穷。

建议你自己编程算一下结果，很容易验证。
作者: loy_20002000    时间: 2017-7-4 22:19
牛腰 发表于 2017-7-4 20:55
这道题问的不是一天的期望值，而是连续多天（接近无穷天）的总利润。如果面包总量小于当天的市场需求，没 ...

这里先假设面包的保质期较长，就打1个月吧（这个假设不合理，仅仅为了讨论的方便）。在这段时间生产日期较长的面包被降价销售，而新鲜一些的降价面包不断替换生产日期较长的。如1周的面包替换2周的面包。

1.题目给的是大样本下5个情况的概率分别为20%，我假设它是真实的参数估计。120的进货量滞销有两个情况100、110，分别滞销20、10；而存货不够有两个情况130、140，缺口是10、20。由于各项是等概率的，在时间足够长的情况下，滞销的存货被后者吃掉是肯定的。

2.日期望值可以知道日平均值是多少。120的期望是108,110的期望是106。根据弱大数定律，日平均值会在期望附近震荡，不严格的说日平均值==日期望。由此可见120优于110。

3.利润趋近于负无穷的说法不成立。以下分情况说明，均设进货120，进货投入=480。

销售100。销售收入=500，当日利润=销售收入-进货投入=20。

销售110。销售收入=550，当日利润=550-480=70。

销售120。销售收入=600，当日利润=600-480=120。

在不计算滞销的剩余面包的情况下当日利润为正数！哪怕是最糟糕的100个/日也有20元的利润。再加上滞销面包降价销售回笼的资金可以算作纯利润，利润只会更高。

说明完毕。
作者: 牛腰    时间: 2017-7-4 22:55
loy_20002000 发表于 2017-7-4 22:19
这里先假设面包的保质期较长，就打1个月吧（这个假设不合理，仅仅为了讨论的方便）。在这段时间生产日期 ...

你的说明只有在滞销面包成本为零的情况下才是对的。你自己编程算过吗？
作者: loy_20002000    时间: 2017-7-4 23:00
本帖最后由 loy_20002000 于 2017-7-4 23:02 编辑
牛腰 发表于 2017-7-4 22:55
你的说明只有在滞销面包成本为零的情况下才是对的。你自己编程算过吗？ ...

滞销面包统统销毁依然有利润，这还需要编程？
作者: 牛腰    时间: 2017-7-4 23:20
loy_20002000 发表于 2017-7-4 23:00
滞销面包统统销毁依然有利润，这还需要编程？

它们的成本怎么算？
作者: loy_20002000    时间: 2017-7-4 23:21
loy_20002000 发表于 2017-7-4 23:00
滞销面包统统销毁依然有利润，这还需要编程？

再补充一个计算。假设日进货量140，日成本=560，以日为单位。

销售100。销售收入=500，利润=销售收入-日成本=500-560=-60

销售110。销售收入=550，利润=550-560=-10

销售120。销售收入=600，利润=600-560=40

销售130。销售收入=650，利润=650-560=90

销售140。销售收入=700，利润=700-560=140

日平均利润=40。注意：滞销面包销售率为0，而日均依然盈利。
作者: loy_20002000    时间: 2017-7-4 23:37
牛腰 发表于 2017-7-4 23:20
它们的成本怎么算？

例如。日剩余20个面包就是80的成本，我的处理是不再上市，净亏损80。在这种极端假设下依然盈利。

另外补充一个，楼主图表的后两项计算是错误的。因为滞销面包不可能销售完，累积是正无穷。

作者: 牛腰    时间: 2017-7-4 23:53
loy_20002000 发表于 2017-7-4 23:37
例如。日剩余20个面包就是80的成本，我的处理是不再上市，净亏损80。在这种极端假设下依然盈利。

另外补 ...

我的理解是滞销面包必须先卖完才能卖新鲜面包。在那种情况下滞销面包数量积累是正无穷，利润就是负无穷。如果卖面包的顺序是可以先卖新鲜面包，然后再卖滞销面包，那么滞销面包全扔了都有利润。所以问题的关键在新鲜和滞销面包卖出的优先权，得出的结果就不一样。
作者: 视觉错误    时间: 2017-7-5 00:11
想复杂了，选择题而已，不会去考虑卖不掉的影响第二天的销售。
“剩余的面包次日将以每个3元‘处理’。”——我理解“处理”，就是不计入正常销售的。
作者: loy_20002000    时间: 2017-7-5 00:21
牛腰 发表于 2017-7-4 23:53
我的理解是滞销面包必须先卖完才能卖新鲜面包。在那种情况下滞销面包数量积累是正无穷，利润就是负无穷。 ...

日进货量为100、110、120可以卖空滞销面包，130、140累积的滞销面包是正无穷。

你的假设不合理呀。新面包的利润高于滞销面包，商家不可能优先卖积压货呀。可以这么假设商家新+旧一起卖，消费者优先选择旧货，这又是另外一个问题了。

作者: 大黑蚊子    时间: 2017-7-5 00:44
这个题目是从哪儿来的啊？
我估计出题人的本意也就是考一下期望函数的计算而已，隔夜的面包根本不计入销售量
作者: 牛腰    时间: 2017-7-5 05:25
loy_20002000 发表于 2017-7-5 00:21
日进货量为100、110、120可以卖空滞销面包，130、140累积的滞销面包是正无穷。

你的假设不合理呀。新面 ...

按照这道题的题意，商家优化利润的唯一方法是决定每天的进货量，而不是选择先卖哪些面包。既然题目提到滞销的面包第二天每个3元处理掉，我的理解是滞销的面包要先卖掉以后才卖新鲜面包。这不是商家的选择。在这个前提下日进货量如果是120，滞销面包是卖不完的，理由就是我前面说的不对称性质。足够多天以后每个卖掉的面包都是滞销面包，所以每天都是负利润。

如果“第二天每个3元处理掉”意思是卖给第三方，3元是salvage value，第二天只卖新鲜的，那么我同意120是最优选择。
作者: loy_20002000    时间: 2017-7-5 22:09
绿葱头 发表于 2017-7-4 13:53
对“需求没有得到满足也是亏损”这句不解，我刚写了程序用随机数模拟了下，被结果吓到了，如果按照前一天 ...

我的回复与计算有些我认为【显然】的前提，再次详细说明一下。先从以下这个回复说起。

3.盈利的分析。进货为120，根据题意60%的情况下是这个销量（120、130、140的消费者需求量都是销售总计120个面包），20%的情况是100,20%的情况是110。

E(X)=120*60%+80*20%+100*20%=72+16+20=108

我的计算基于几个前提：

1、滞销面包的保质期足够长。这是核心假设，之后的所有计算都是基于这个。只有几天保质期肯定不行，至少要有两个星期左右的保质期（假设的说法，仅仅帮助您理解。就不定量化了）。

2、商家营业的时间足够长。理想的假设是正无穷，现实不允许。总之尽量长。

3、滞销面包的处理方式。可以有两种。一（3.1）是转交给第三方处理，如贩卖给学校食堂、餐馆。二（3.2）是与新鲜面包一起销售，这就涉及几种方式。消费者的偏好如下所列。

3.2.1.堆栈式。此方法遵循先入后出原则，也就是说新鲜面包永远优先被消费者购买。

3.2.2.队列式。此方法遵循先入先出原则，也就是说降价处理面包永远优先被消费者购买。

3.2.3.数组式。此方法遵循等概率原则，也就是说消费者挑选到任意一个面包的概率相同。

我的计算可以处理3.1与3.2.1，这里说明。

---------------------

3.1）从题意知道单日有x个新鲜面包，我以x=120来说明。以日为单位显然有，利润=新鲜面包销售量（每单位+1人民币） - 滞销面包数量（每单位-1人民币），所以总利润就是所有销售日利润的累加。总利润=利润1+利润2+……+利润n。

日平均利润=日期望，故而知道了日期望就知道了日平均利润，知道了日平均利润就知道了总利润。

E(X)=120*60%+80*20%+100*20%=72+16+20=108
这是怎么来的呢。

140个面包情况下仅有120个新鲜面包，所以利润=120，

130个面包同上，所以利润=120，

120个面包同上，所有利润=120，

110个面包就不同了。利润=新鲜面包销售量（每单位+1人民币） - 滞销面包数量（每单位-1人民币），所以利润=110-（120-110）=100，

100个面包同理，利润=100-（120-100）=80，

综合以上期望为108。

--------------------

3.2.1）新鲜面包优先被购买意味着可以套用3.1）的计算方式。但这里需要一个前提，剩余面包一定能全部卖出去，并且是在没有过保质期之前卖出去。

首先我来说明一定能卖出去。

面包剩余的期望=20*20%（100个面包剩余20个，其余类推）+10*20%+0*20% -10*20% -20 *20%=0，显然剩余面包在销售时间足够长时是可以卖光的。

如何保证不会过期。

假设120份面包剩下20份，这里记做d（n）。设d（k）为早购入的面包，则构建d（k）、d（k+1）、d（k+2）、……、d（n）的队列，将队列压入堆栈A，然后从堆栈A中取元素放入堆栈B。设新面包为t（n+1），将t（n+1）压入堆栈B，则从堆栈B取元素的次序为t（n+1）、d（k）、d（k+1）、d（k+2）、……、d（n）。当日剩余重复之前操作。这是我个人的一些看法，不具有多少必然性。

强调一下3.1与3.2.1计算的逻辑。你在主题楼的问题如下：

网上有种答案感觉是基于不影响第二天的销售数量计算的

3.1）情况下明显与明天的利润无关，因为滞销货都被处理掉了。

3.2.1）情况下明天的利润只与明天新鲜面包销售量与明天滞销面包数量有关。滞销面包无论销售多少都与利润无关，在计算中滞销面包已经被算作之前的损失了。

如第一天滞销20个，收益为-20，滞销货已经计入第一天的收益表中了。第二天卖出第一天的滞销面包，再计算昨日滞销面包的收益就重复计算了。

---------------------------

3.2.3）的计算问题。假设消费者等概率选择面包是比较合乎现实的。这个假设最简单的解决办法是写个程序并且找来真随机数列输出5个等概率反复跑。不做其他假设的情况下我不知道能不能解，这个先按下吧。


作者: 老马丁    时间: 2017-7-5 23:04
问了一下一个OR的教授。典型的newvendor problem。

答案 120. 因为最优库存是让销量低于库存的概率为1/2. 当库存为120时，销量低于库存的概率刚好为1/2.
这个1/2怎么来的呢？给定利润和库存成本，反解，直接套公式。具体解法看wiki吧。
作者: 牛腰    时间: 2017-7-5 23:05
loy_20002000 发表于 2017-7-5 22:09
我的回复与计算有些我认为【显然】的前提，再次详细说明一下。先从以下这个回复说起。

基本上同意你的分析，唯一的一点是如果市场需求平均120，店家每天进货120，滞销面包不仅不会卖完，而且会积累到无穷大。举个简单的例子：第一天市场需求是140，120个新鲜面包全部卖完。第二天市场需求是100，有20个滞销面包。前两天的平均需求是每天120，但是店家进货240只卖出去220。就是因为我前面提到的不对称因素。如果连续几天市场需求大于140（小概率事件，但是只要有足够多的天数还是有可能发生的）导致每天的滞销面包数量都是0，那么以后几天面包就会滞销。

所以如果市场需求的平均是120，而店家每天进货订死在120，每天的平均销售量肯定小于120。足够多的天数以后面包就会滞销，时间越长积累的滞销数量就越多。
作者: 水风    时间: 2017-7-5 23:08
我感觉这道题可以用两种方法去理解。一种就是用最不用动脑子的，就是求平均日销量。因为无论买多还是买少都是亏损，那么按照平均日销量来定，绝对是最大利益化。

另外一种就是按照你给出的这个列表，把所有的情况给列表然后把所有的可能都包括进去来计算，反正每种情况都是概率一样的。

这道题我觉得考察的应该是不动脑子的那点。不是让你真的去计算。

这道题因为做了简化，所以感觉要你仔细计算。实际上，正常情况下见到的是100到140的正态分布。那个你怎么算？但结果还是一样的。就是计算平均值而已。
作者: loy_20002000    时间: 2017-7-5 23:09
牛腰 发表于 2017-7-5 05:25
按照这道题的题意，商家优化利润的唯一方法是决定每天的进货量，而不是选择先卖哪些面包。既然题目提到滞 ...

根据图表的计算，题目的3元处理掉应该是指销售给第三方，所以图表后两项是正确的。

既然题目提到滞销的面包第二天每个3元处理掉，我的理解是滞销的面包要先卖掉以后才卖新鲜面包


这是不符合利润最大原则的，当然原题本就有歧义。
作者: loy_20002000    时间: 2017-7-6 01:02
牛腰 发表于 2017-7-5 23:05
基本上同意你的分析，唯一的一点是如果市场需求平均120，店家每天进货120，滞销面包不仅不会卖完，而且会 ...

我们不妨把问题换个形式，这样就不用考虑保质期一类的问题了。我的做法是把面包换做足球一类商品，每日进货改成每个月进货，这样显得合理一些。这里假定你接受我设置的条件了呀。

你的意思我是这么理解的。s=140连续出现的时候没有货物的积压（黑天鹅事件），之后s=100连续出现（也是黑天鹅），由于二者发生的概率极低，所以s=100造成的货物积压没法通过s=140消除。但有两点不妥。

一是有限重复实验下货物积压确实难以消化，但它是一个常数。例如s=100导致积压了200的货物，它不会减少也不会增加的，就算以后每次都是s=100，结果也一定是常量。

二是这里的重复实验次数是正无穷，无穷下有限分析方法就失效了。连续多次s=100的黑天鹅导致的货物积压，它是不可能进一步增大的，因为总会再次出现s=140的黑天鹅。除非s=100的概率大于s=140，但条件是等概率。我觉着你被自己误导了，即觉得s=140的时候一定是没有滞销货，之后s=100的时候货物累积增加。一方面货物在增加，一方面遇到s=140的情况下货物却没有滞销。

之前计算了单日剩余期望=0，根据弱大数定律均值一定是无限接近于0呀。需要澄清的是均值=0不等同于剩余货物之和=0。例如10000/正无穷=0，但总货物剩余却是10000。可是这个结果的出现一定是由于s<120的连续出现，如连续出现了500次s=100。记得加莫夫举过一个例子，两个房间中间有一个小孔相连，大部分情况下两个房间的空气是均匀的；但会出现A房间的空气统统跑到B房间去，A房间居然成为真空，这个事件不是不会发生，而是发生的概率极低。发生概率极低的事件通常被当做不可能发生的。虽然剩余货物为10000数值很大，但这么极端的情况都出现有什么理由怀疑，s=140连续发生500次甚至更多为不可能呢。

弱大数定律：
[attach]71562[/attach]

作者: 牛腰    时间: 2017-7-6 01:22
本帖最后由 牛腰 于 2017-7-6 01:41 编辑
loy_20002000 发表于 2017-7-6 01:02
我们不妨把问题换个形式，这样就不用考虑保质期一类的问题了。我的做法是把面包换做足球一类商品，每日进 ...


我从没考虑过保质期，一直假设面包搁置多久都能以每个3元的价格卖出去。我前面可能没有说清楚，120/130/140连续发生N次以后再发生大约N次的100/110/120导致一定数量的面包滞销，再往后滞销数量不再增加。可是在总天数是无穷的情况下N本身没有上限，而滞销数量和N有正对应的关系。其实滞销数不需要10000，只要保持在150就可以保证新鲜面包卖不出去了（条件是滞销面包的优先权高于新鲜面包）。

如果你有怀疑的话建议你自己建个Monte Carlo模型跑一下，不会花很长时间就能验证。
作者: Dracula    时间: 2017-7-6 01:48
本帖最后由 Dracula 于 2017-7-6 01:51 编辑

如果按你的理解存货影响到下一期的需求，并且未来有无穷期的话，解这个题需要使用dynamic programming。但是因为这个题没给出一个discount factor，而如果你不discount 未来的利润的话，无穷期的利润加起来会是无穷大，无穷大的量的最大化问题是没有解的，因此这应该不是出题人的思路。如果discount factor小于1的话，用dynamic programming应该可以解的。

（Dynamic programming当年是我学宏观经济学的时候学的，除了当年考试以外就再也没用过，你要是真想要答案的话，给我点时间，把这些捡回来）

作者: loy_20002000    时间: 2017-7-6 02:00
牛腰 发表于 2017-7-6 01:22
我从没考虑过保质期，一直假设面包搁置多久都能以每个3元的价格卖出去。我前面可能没有说清楚，120/130/1 ...

你的这句话是错误的呀。

130/140连续发生N次以后再发生大约N次的100/110导致一定数量的面包滞销，再往后滞销数量不再增加


简化点，仅考虑100、140两种情况。连续发生N次140，再发生N次100，这里滞销数是t。之后有可能发生N次同一连续事件，分两种情况讨论：

1.如果发生N次100，那么之后发生N次140的可能性增加，于是对冲滞销依然为t。这是你的看法。

2.如果发生N次140，那么积压存货被对冲，滞销为0。

另外在讨论无穷的时候，你可能忽略了它的特殊性。M*N次140也是极小概率事件，也有发生的可能。也就是说不论你的N*20多么大都有消掉的可能。你在用有限思维考虑无穷，例如大名鼎鼎的分球悖论，无穷的情况下+选择公理成立，一个球可以分成无穷多个同样大小的球。有限下维持某个足够大剩余数的思路在无穷下不成立的。在无穷的前提下货物剩余可以极大（可以大于任何一个自然数），但一定不是无穷大。除非100的概率高于140。

你的意思可能是这样的。初始条件下100的剩余是20，140理论剩余是-20可实际却是0。经过足够多重复实验这种不对称导致100的货物剩余没法消掉。可是呀，t足够大，140的负期望就发挥作用了。
作者: 牛腰    时间: 2017-7-6 02:02
本帖最后由 牛腰 于 2017-7-6 02:10 编辑
Dracula 发表于 2017-7-6 01:48
如果按你的理解存货影响到下一期的需求，并且未来有无穷期的话，解这个题需要使用dynamic programming。但 ...


我想每日的平均利润可能是个更好的metric。只要每日进货量固定在x，支出就是4x，最低440（4X110），最高560（4X140）。Revenue最低300（卖出100个滞销面包，每个3元），最高700（卖出140个新鲜面包，每个5元）。那么每天的利润最坏的情况是300-560=-260，最好的情况是700-560=140。无穷期的日均利润只能在-260和140之间。这样你就不需要discount factor了。
作者: 牛腰    时间: 2017-7-6 02:06
loy_20002000 发表于 2017-7-6 02:00
你的这句话是错误的呀。

你还是自己作个模型跑一次，拿到结果以后再来讨论吧。自己动手验证是最好的学习方法
作者: loy_20002000    时间: 2017-7-6 02:11
牛腰 发表于 2017-7-6 02:06
你还是自己作个模型跑一次，拿到结果以后再来讨论吧。自己动手验证是最好的学习方法 ...

不止我可以做，你也可以做呀。
作者: Dracula    时间: 2017-7-6 02:16
牛腰 发表于 2017-7-6 02:02
我想每日的平均利润可能是个更好的metric。只要每日进货量固定在x，支出就是4x，最低440（4X110），最高5 ...

首先一个无穷大的量的最大化问题是没有解的，[latex]2*\infty[/latex]和[latex]3*\infty[/latex]一样大。。因此这个问题要properly defined的话，必须需要一个小于1的discount factor。

第二你的解法假设商家每日的生产量是永远不变的。最优解应该不是这样，而是应该随前一日的库存量而变化。生产量应该是前一日遗留下的库存量的函数。要解这种问题需要使用dynamic programming。但是怎么用，我现在有些想不起来了，需要温习一下。


作者: loy_20002000    时间: 2017-7-6 02:19
本帖最后由 loy_20002000 于 2017-7-6 02:20 编辑
Dracula 发表于 2017-7-6 02:16
首先一个无穷大的量的最大化问题是没有解的，和一样大。。因此这个问题要properly defined的话，必须需要 ...

按照你的解法就歪楼歪多了，不过我还是很想看一看。期待。。。。。。
作者: Dracula    时间: 2017-7-6 02:25
loy_20002000 发表于 2017-7-6 02:19
按照你的解法就歪楼歪多了，不过我还是很想看一看。期待。。。。。。

楼主我估计不是在上dynamic programming这门课。出题人的思路肯定不是在我说的这个方向。应该就是一个1期问题，不考虑库存对第二天需求的影响。

但如果是个无穷期问题，并且库存对第二天的需求有影响的话，那这就是一个典型的dynamic programming问题。用它应该是最常规的解法。

作者: 牛腰    时间: 2017-7-6 02:31
本帖最后由 牛腰 于 2017-7-6 02:34 编辑
Dracula 发表于 2017-7-6 02:16
首先一个无穷大的量的最大化问题是没有解的，和一样大。。因此这个问题要properly defined的话，必须需要 ...


第一，总利润是无穷的，但是日均利润不会是无穷的，所以我觉得算日均利润有可比性。

第二，我同意最优解应该能根据库存量变化，但是选择题问的是每日应该进货多少，而不是inventory target应该是多少。如果改变的这个条件的话你就不是在解楼主那道题了。
作者: 牛腰    时间: 2017-7-6 02:39
loy_20002000 发表于 2017-7-6 02:11
不止我可以做，你也可以做呀。

我已经作了，结果证实了我的看法。假设滞销面包的优先权高于新鲜面包，在每日进货110时日均利润是正数，120/130/140时日均利润是负数。一般这种模型都要自己做了才能信服结果，所以我和你说了好几次要做模型。
作者: Dracula    时间: 2017-7-6 02:47
Dracula 发表于 2017-7-6 02:25
楼主我估计不是在上dynamic programming这门课。出题人的思路肯定不是在我说的这个方向。应该就是一个1期 ...

我刚才在纸上写了一下这个问题，意识到那个目标函数是不可导的，因此用普通微积分的办法没法解。应该是使用数值方法。但数值方法怎么用我没学过，不清楚。
作者: loy_20002000    时间: 2017-7-6 03:27
牛腰 发表于 2017-7-6 02:39
我已经作了，结果证实了我的看法。假设滞销面包的优先权高于新鲜面包，在每日进货110时日均利润是正数，1 ...

好吧，你和我讲从来不在一条轨道上。我给洋葱头的回复已经清楚说明我的前提条件了。你说的只是我给出的四个滞销处置方案的一种，而我说明了两种，剩下那种没思路所以我没有解决过。

我一直以为讨论的是原题意下进货为120剩余面包是否为零。你的处置方法是我总结的队列式。优先销售降价面包我算过，我的方法由于需要分情况处理最后没结果，我可从来没有说过这个情况下的结论。

之后的讨论条件还是全部给出吧，否则我又不知道讨论的是什么了。
作者: 牛腰    时间: 2017-7-6 03:45
本帖最后由 牛腰 于 2017-7-6 04:06 编辑
loy_20002000 发表于 2017-7-6 02:11
不止我可以做，你也可以做呀。


刚才把我做的模型打开看一下，连续天数足够多的话每个选项的日均利润是：
110：＋102元
120：－110元到－120元之间
130：－160元
140：－200元

日进货120的日均利润收敛很慢，但是肯定是负数。

至于每日进货120，假设跑40万天左右，运行了几次，最后一天的滞销数量最多超过１万，最小的也有３千多。日均需求（～120）减去日均销售量，差别大约是0.015。所以你不可能保证滞销的面包都能卖完。

作者: 牛腰    时间: 2017-7-6 04:10
本帖最后由 牛腰 于 2017-7-6 04:20 编辑
loy_20002000 发表于 2017-7-6 03:27
好吧，你和我讲从来不在一条轨道上。我给洋葱头的回复已经清楚说明我的前提条件了。你说的只是我给出的四 ...


我刚才想不起具体数字，所以就写了我能记得的结果。我已经把我的具体结果贴出来了，愿不愿意自己验证就随便你了。
作者: loy_20002000    时间: 2017-7-6 06:42
牛腰 发表于 2017-7-6 04:10
我刚才想不起具体数字，所以就写了我能记得的结果。我已经把我的具体结果贴出来了，愿不愿意自己验证就随 ...

你的思维有几个误区。

1.弱大数定理的含义。



通俗的说法是：当n趋近无穷时，【均值与期望的距离大于任意实数】的可能性无限趋近于0。

假设t为任意小数，|Xn-u|>t的可能性接近0。也就是说Xn无限接近u。你给出一个0.015的实验差值，理论上说把n继续调大，绝对值会小于这个数字。

2.你实验方法的错误。

你应该找的是货物剩余Bi=0的出现频率，而不是某个时刻Tn货物剩余Bn是多少。T1、T2、……、Tn是销售日期序列，你应该找的是Bi（1<= i <=n）=0在Ti 出现了多少次。

理由是：

Bn为大数，由于100、110可以与130、140对冲，所以剩余将一直在Bn附近震荡。可我们知道初始剩余为0，为何会形成大数Bn呢。

过程是这样的，由于条件是等概率，当B1=0时反复出现130、140，所以接下来出现100、110的可能性很高，并且真的出现了，于是乎B1诞生了。按理剩余在B1附近震荡，可同样的剧情又上演了。剩余再次冲击0，然后再次反弹形成B2。以此类推，Bn是经过了B1、B2、……B（n-1）一系列过程形成的。每形成一个Bi 剩余都要清空一次（Bj=0,j<i）。

正如在一条实数轴上随便砍一道，大部分情况下得到的都是无理数（无理数的势大于有理数），但不能因此说有理数不存在。我们说Bi趋近于正无穷的意思是Bi >Bj（j<i），像正弦曲线是没有极限（sin x，x趋于无穷）与无穷大一说的，Bi的变化与它十分类似。

如果你的实验没有我这里描述的过程，例如只经过少数几次清零Bn就达到3000up或更多，或是剩余一直在积累却几乎没有清零。要么你的概率设置有问题，要么你的随机是假随机。维纳——诺依曼计算机是没法产生真随机的。

3.均值与期望。

均值可以近似期望但毕竟不是期望，期望是一个理想化的概念，而均值是一个现实的统计量。所以剩余均值 Bi/i 的分子货物剩余Bi可以是任意大数。但这并不影响我的结论。按照我的方法得出的收益趋近于正无穷，而货物剩余在某个时刻Tn仅仅是一个常数，何况它还会回到0。

完毕。
作者: 牛腰    时间: 2017-7-6 09:58
本帖最后由 牛腰 于 2017-7-6 19:24 编辑
loy_20002000 发表于 2017-7-6 06:42
你的思维有几个误区。

1.弱大数定理的含义。


1．市场需求量和销售量是两个不同的概念，前者是纯粹的需求，和供给量无关，但是每一天的销售量则是需求量和供给量（在这里是新鲜面包和滞销面包数量的和）里最小的那个数。需求量和销售量只有在供给量每一天都大于需求量的时候才会相等。如果需求量大于供给量，多出来的部分属于lost sales，不会留到第二天。你把这两个概念混淆了。题目给了需求量（100，110，120，130和140 随机分布），但是只有在每天进货140的情况下两者才会相等。所以如果u是平均需求量（即120），而Xn是前n天的平均销售量，弱大数定率对于|Xn-u|根本不适用，因为Xn和u虽然有关联，但是它们是两个完全不同的东西。

2．你指出我试验方法的缺陷是对的，我接受。我之所以提出日均需求和日均销售量的差别是因为我也觉得最后一天的滞销数量只是一个点，日均需求和日均销售量的差别更能说明问题。我也怕随机数的产生有bias，所以我作了两组试验，第一组随即产生100到140的需求量，第二组里的需求量把第一组倒过来，等于240减去第一组的需求量，这样100就变成140，110变成130。。。两组的模拟结果是一致的。

3．你说的Bi是否清零问题很有意思，我以前没有想到这一点。如果我连续跑82万天，清零的次数每次模拟有几百个到几千个。有意思的是相邻的两次清零天数之间如果相隔n天，在这段时间里总销售量总是等于120n（废话），但是总需求要么等于120n，要么大于120n，从来不会小于120n。原因就是我说的不对称性质。也就是说相邻的两次清零，要么会积累lost sales，要么不会，但是lost sales永远不会减少，所以在n天里总销售量 ＝总需求量－lost sales，n趋向无穷的时候平均需求量无限趋向120，但是因为lost sales大于0，平均销售量会趋向一个小于120的数。所以我前面给出的0.015的差值，我觉得不是实验误差，因为41万天和82万天的模型得出的结果都是这个数。如果是实验误差的话，天数翻倍，实验误差应该减少30%，即1/sqrt(2)　才对。我觉得这个0.015的差值应该包含了每天lost sales的平均值。

4．你在第三点里提到的均值与期望，是销售量的均值和需求量的期望，它们的差不会趋于零，因为它们根本就是两吗事。

5．我再次建议你自己作个模型跑一下，这是检验自己答案非常有效的手段。
作者: loy_20002000    时间: 2017-7-6 19:30
牛腰 发表于 2017-7-6 09:58
1．市场需求量和销售量是两个不同的概念，前者是纯粹的需求，和供给量无关，但是每一天的销售量则是需求 ...

1.基本概念的厘清。

题目给出了根据【历史统计情况】得出来的【日销售量】。所以题目给出的数据类型是【统计量】，不是【真实的参数估计】。我在给你的第二个回复假设了它们是真实的参数估计（实际上参数估计没有真实与否这一说，真实参数只有上帝知道），这样处理起来会显得简单一些。这里不符合题意，可是也有一些合理性，毕竟现实的销售概率不会都是等概率这么完美，是有零有整的；商品销售也不会都是100、……、140这类“完美数”，既然题目假设很完美我就干脆让它更完美。所以有了【剩余货物的期望】【日利润的期望】【日销售量的期望】。有了这些期望就可以求【剩余货物的平均值】【日利润的平均值】【日销售量的平均值】。我的所有讨论是建立在如上假设之上的，所以使用了弱大数定律。

我理解你的意思，【市场需求量】是一个客观参数，消费者起决定性因素。而【市场销售量】取决于两个因素，一是消费者的购买意愿，二是商家有多少库存，这两者中min的那个决定数值。

你的意思是【日平均销售量】小于【日平均需求量（120）】。按你的语境来说，我的意思是【日平均消费量】接近【日平均需求量】。显然，我说的东西与你坚持的根本就是一回事儿。

2.现实问题的处理。

前面多次强调了【剩余货物的平均值】问题。诚然分子很大，但平均到每天几乎能忽略不计的。我的想法是【日均需求量-日均销售量】可以无穷小，你的数据是0.015。以你的数据为准，这个损失是可以接受的。

我上一个回复3）讲的不是【销售量的均值和需求量的期望】呀。而是【剩余均值与剩余货物】。我主要是强调概念的差别。

这里说下大数定律的现实化考虑。题目给出的是日销量，我把它当做真实参数，于是就有了【日销量期望】这个东西。而【日销售均值】就可以和【日销量期望】发生一些关联。

如果u是平均需求量（即120），而Xn是前n天的平均销售量，弱大数定率对于|Xn-u|根本不适用

显然如你所说，这里是不能用弱大数定律的。一个均值逼近另外一个均值不是弱大数定律的内容。但在现实中这是OK的。歪一个，说一个中学教科书的例子。

用一枚质地均匀的硬币做投掷实验，当重复实验次数足够多时，任意一面出现次数的平均值是0.5。当重复实验次数较少时平均值在0.5附近剧烈震荡；而当重复实验较多后震荡变小；当重复实验足够多后震荡变得极其微小。这是大数定律的思想源泉，也是频率派概率论的根基。虽然它并不严格，但极具实用性。甚至有人专门做过上万次的抛掷硬币实验来验证它的正确性，实验结果与预期一致。

比较有趣的是概率哲学史的英国学派有人坚称，单次投掷不规则硬币出现任意一面的概率是0.5。由于这个思想的缘故他们认为只有实验次数足够多后概率才是偏离0.5的，但单次实验任意一面的可能性完全一致。例如重复试验下正面的可能性是0.95，他们认为重复实验中有可能出现连续多次反面的情况，虽然它的可能性只有0.05。所以应该认为正反面的概率都是0.5。

基于这个朴素的思想，有理由认为如下。

样本1，A事件重复实验k次；样本2，A事件重复实验n次。n远大于k。由于样本2更接近真实的期望值，所以样本2估计的参数更准确。样本1也是逐渐逼近期望值的，在不知道真实参数的情况下有理由认为样本1逼近的是样本2。现实的处理中真实参数是不得而知的，哪怕是抛掷硬币或筛子的重复实验也是不可知的，因为这些物品的质地不可能真正的均匀（如筛子就不可能是均匀的），二是基于重复实验找真理的思想必然的推论是真理只能靠近不能知晓。所以通用的做法是用大样本统计量当做真理，如PERT方法下均值=期望，标准差=经验估计+往期数据。

不论是我的文字分析法还是你的实验检验法，好用就行。不用大数定律一类方法，认为小样本统计量一直在逼近大样本统计量也是可以的，这的情况是【我们求的日均销售量】一直逼近【题意的日均销售量】。

3.我亲自实验的问题。

我猜测你的工作与机器学习一类有关，所以动手检验来得快。你说的蒙特卡洛方法我知道原理，但具体操作不在行。并且我多年不碰代码了（2008年至今），对于我来说有些麻烦的。所以还是纯理论分析吧。
作者: 牛腰    时间: 2017-7-6 21:21
本帖最后由 牛腰 于 2017-7-6 23:26 编辑
loy_20002000 发表于 2017-7-6 19:30
1.基本概念的厘清。

题目给出了根据【历史统计情况】得出来的【日销售量】。所以题目给出的数据类型是【 ...


1．在供大于求的情况下销售量和需求量是相等的，如果每天都有150个面包可以出售，统计结果是销售量在100到140之间平均分布，不考虑价格和其它因素的影响，这就是需求量的分布。做到这一点并不难，对这道题来说这也是合理的，否则这道题没法做，因为它没有提供之前库存管理的方法。所以对这道题来说面包需求量就是100到140这5个数之间的平均分布。

即使这个平均分布是在每天有140个面包可以出售的情况下得到的结果，你也不能假设每日进货120的情况下还能得到同样分布的销售量，因为供给方面的条件变了。

2．日均销售量 = 日均需求量 – 日均lost sales。如果天数趋向无穷时日均lost sales大于0并且不趋向无穷小，我们说的就不是一回事了，因为日均销售量不会趋向日均需求量。在41万天和82万天两种情况下都得到大约0.015的差额，有理由相信这大约等于日均lost sales而不是实验误差，否则这个数应该随着天数的增加而减少。

3．如果日均需求量=120，日均lost sales大约0.015，那么日均lost sales就是滞销面包数量的的日均积累，在天数趋向无穷的情况下滞销面包数总数会变得很大（尽管在某些天里还会归零）。我在模型运行结果里看到过滞销面包最大（不是最后那一天）超过２万的。假设滞销面包的优先权大于新鲜面包，这会影响到日均销售量的mix，即卖出去的新鲜面包和滞销面包的比例。

4．回到题目里的利润问题，根据我的模型结果，每天进货120，日均利润大约是–115，用鸡兔同笼的方法，得出新鲜面包的日均销售量大约是3，滞销面包的日均销售量大约是117。如果每天进货110，模型结果日均利润是102，那么新鲜面包的日均销售量大约是106，滞销面包的日均销售量大约是4。这个结果符合我在模拟前做的qualitative分析，既每日进货120/130/140，利润是负的，而每日进货110的话利润是正的，所以答案应该是A：110。
作者: loy_20002000    时间: 2017-7-8 18:28
牛腰 发表于 2017-7-6 21:21
1．在供大于求的情况下销售量和需求量是相等的，如果每天都有150个面包可以出售，统计结果是销售量在100 ...

经过我反复实验，你的结论不成立。

1.我的实践

1.1.代码

#include <stdlib.h>
#include <stdio.h>
#include <time.h>           //使用当前时钟做种子


double i, S0,Add,Sub,Sta,Sn,Zero,Max,Sv;
    //
int D,GetRam,Times,Zero_man;    //man==万   


                 


void main( void )
{   
   
    S0=0;
    Sn=S0;
    Add=0;
    Sub=0;
    Sta=0;
    GetRam=0;
    D=0;
    Zero=0;
    Max=10000000;
    Times=0;
    Zero_man=0;
   
    srand( Times=(unsigned)time( NULL ) );  
   
   
    for( i = 0; i < Max;i++ )                          
    {
        GetRam=rand();
        D=GetRam%10;
                                                 //printf("D=%d\n",D);
        if (D==0 || D==1)
        {
            Add++;
            Sn=Sn+20;
            
        }
        else if (D==2 || D==3)
        {
            Add++;
            Sn=Sn+10;
        }
        else if (D==4 || D==5)
        {
            Sta++;
            Sn=Sn+0;
        }   
        else if (D==6 || D==7)
        {
            Sub++;
            if(Sn>=10)
                Sn=Sn-10;   
        }   
        else if (D= 8 || D==9)
        {
            Sub++;
            if (Sn>=20)
                Sn=Sn-20;
            else if (Sn<20 && Sn >=0)
                Sn=0;
        }              
        if(Sn==0)
        {
            Zero++;
            if(i>=100000)
                Zero_man++;
               
        }   
        
   
    }                                              // rand() 0~65535 32767
            
        Sv=Sn/Max;
        
        printf("这里的日进货为120个面包\n\n");
        printf("Add，库存增加次数=%f\n",Add);
        printf("Sta，库存不变次数=%f\n",Sta);
        printf("Sub，库存减少次数=%f\n",Sub);   
        printf("Sn，库存总额=%f\n",Sn) ;   
        printf("Zero，库存清空次数=%f\n",Zero);
        printf("Zero_man，运行十万次以上库存清空次数=%d\n",Zero_man);
        printf("Sv，日均滞销库存=%f\n",Sv);     
        printf("Times，随机化初始时间参数=%d\n",Times);
        printf("Max,反复实验次数=%f\n",Max);
            
            
}

1.2.代码的思路如下

为了取得较满意的随机数，我先用日期初始化随机函数，然后用随机函数输出事件发生的频率。

1.3.运行数据

为了使得结果更具说服力，我分别贴50万、100万、500万、1500万、10亿的分别5个结果。

50万——

1）
这里的日进货为120个面包

Add，库存增加次数=199905.000000
Sta，库存不变次数=100062.000000
Sub，库存减少次数=200033.000000
Sn，库存总额=5960.000000
Zero，库存清空次数=997.000000
Zero_man，运行十万次以上库存清空次数=646
Sv，日均滞销库存=0.011920
Times，随机化初始时间参数=1499499993
Max,反复实验次数=500000.000000

--------------------------------
Process exited after 0.1982 seconds with return value 31
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=200099.000000
Sta，库存不变次数=99865.000000
Sub，库存减少次数=200036.000000
Sn，库存总额=2340.000000
Zero，库存清空次数=689.000000
Zero_man，运行十万次以上库存清空次数=433
Sv，日均滞销库存=0.004680
Times，随机化初始时间参数=1499500050
Max,反复实验次数=500000.000000

--------------------------------
Process exited after 0.1802 seconds with return value 31
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=200716.000000
Sta，库存不变次数=99936.000000
Sub，库存减少次数=199348.000000
Sn，库存总额=23020.000000
Zero，库存清空次数=310.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.046040
Times，随机化初始时间参数=1499500114
Max,反复实验次数=500000.000000

--------------------------------
Process exited after 0.06543 seconds with return value 31
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=200454.000000
Sta，库存不变次数=99822.000000
Sub，库存减少次数=199724.000000
Sn，库存总额=19880.000000
Zero，库存清空次数=1029.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.039760
Times，随机化初始时间参数=1499500186
Max,反复实验次数=500000.000000

--------------------------------
Process exited after 0.04682 seconds with return value 31
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=200036.000000
Sta，库存不变次数=100289.000000
Sub，库存减少次数=199675.000000
Sn，库存总额=7910.000000
Zero，库存清空次数=117.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.015820
Times，随机化初始时间参数=1499500206
Max,反复实验次数=500000.000000

--------------------------------
Process exited after 0.04708 seconds with return value 31
请按任意键继续. . .

100万——

1）
这里的日进货为120个面包

Add，库存增加次数=400100.000000
Sta，库存不变次数=200363.000000
Sub，库存减少次数=399537.000000
Sn，库存总额=15230.000000
Zero，库存清空次数=1294.000000
Zero_man，运行十万次以上库存清空次数=890
Sv，日均滞销库存=0.015230
Times，随机化初始时间参数=1499500299
Max,反复实验次数=1000000.000000

--------------------------------
Process exited after 0.2725 seconds with return value 32
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=399879.000000
Sta，库存不变次数=200225.000000
Sub，库存减少次数=399896.000000
Sn，库存总额=8800.000000
Zero，库存清空次数=252.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.008800
Times，随机化初始时间参数=1499500318
Max,反复实验次数=1000000.000000

--------------------------------
Process exited after 0.0818 seconds with return value 32
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=399594.000000
Sta，库存不变次数=199684.000000
Sub，库存减少次数=400722.000000
Sn，库存总额=1600.000000
Zero，库存清空次数=2793.000000
Zero_man，运行十万次以上库存清空次数=1626
Sv，日均滞销库存=0.001600
Times，随机化初始时间参数=1499500358
Max,反复实验次数=1000000.000000

--------------------------------
Process exited after 0.06388 seconds with return value 32
请按任意键继续. . .

4）

这里的日进货为120个面包

Add，库存增加次数=400999.000000
Sta，库存不变次数=199193.000000
Sub，库存减少次数=399808.000000
Sn，库存总额=29130.000000
Zero，库存清空次数=1835.000000
Zero_man，运行十万次以上库存清空次数=142
Sv，日均滞销库存=0.029130
Times，随机化初始时间参数=1499500391
Max,反复实验次数=1000000.000000

--------------------------------
Process exited after 0.06221 seconds with return value 32
请按任意键继续. . .

5）

这里的日进货为120个面包

Add，库存增加次数=400764.000000
Sta，库存不变次数=199100.000000
Sub，库存减少次数=400136.000000
Sn，库存总额=32210.000000
Zero，库存清空次数=2880.000000
Zero_man，运行十万次以上库存清空次数=1696
Sv，日均滞销库存=0.032210
Times，随机化初始时间参数=1499500420
Max,反复实验次数=1000000.000000

--------------------------------
Process exited after 0.06348 seconds with return value 32
请按任意键继续. . .

——500万

1）
这里的日进货为120个面包

Add，库存增加次数=2001474.000000
Sta，库存不变次数=1000100.000000
Sub，库存减少次数=1998426.000000
Sn，库存总额=36740.000000
Zero，库存清空次数=93.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.007348
Times，随机化初始时间参数=1499500467
Max,反复实验次数=5000000.000000

--------------------------------
Process exited after 0.351 seconds with return value 32
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=1998655.000000
Sta，库存不变次数=1001266.000000
Sub，库存减少次数=2000079.000000
Sn，库存总额=2010.000000
Zero，库存清空次数=5308.000000
Zero_man，运行十万次以上库存清空次数=4428
Sv，日均滞销库存=0.000402
Times，随机化初始时间参数=1499500517
Max,反复实验次数=5000000.000000

--------------------------------
Process exited after 0.3252 seconds with return value 32
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=1999941.000000
Sta，库存不变次数=999562.000000
Sub，库存减少次数=2000497.000000
Sn，库存总额=24000.000000
Zero，库存清空次数=4837.000000
Zero_man，运行十万次以上库存清空次数=4540
Sv，日均滞销库存=0.004800
Times，随机化初始时间参数=1499500699
Max,反复实验次数=5000000.000000

--------------------------------
Process exited after 0.2099 seconds with return value 32
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=2002229.000000
Sta，库存不变次数=999926.000000
Sub，库存减少次数=1997845.000000
Sn，库存总额=84620.000000
Zero，库存清空次数=1896.000000
Zero_man，运行十万次以上库存清空次数=1539
Sv，日均滞销库存=0.016924
Times，随机化初始时间参数=1499500742
Max,反复实验次数=5000000.000000

--------------------------------
Process exited after 0.1914 seconds with return value 32
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=1998393.000000
Sta，库存不变次数=1000616.000000
Sub，库存减少次数=2000991.000000
Sn，库存总额=2340.000000
Zero，库存清空次数=6222.000000
Zero_man，运行十万次以上库存清空次数=5611
Sv，日均滞销库存=0.000468
Times，随机化初始时间参数=1499500776
Max,反复实验次数=5000000.000000

--------------------------------
Process exited after 0.1921 seconds with return value 32
请按任意键继续. . .

1500万——

1）
这里的日进货为120个面包

Add，库存增加次数=5998063.000000
Sta，库存不变次数=3000273.000000
Sub，库存减少次数=6001664.000000
Sn，库存总额=21920.000000
Zero，库存清空次数=11096.000000
Zero_man，运行十万次以上库存清空次数=11059
Sv，日均滞销库存=0.001461
Times，随机化初始时间参数=1499500889
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.6771 seconds with return value 33

2）
这里的日进货为120个面包

Add，库存增加次数=5998591.000000
Sta，库存不变次数=3001925.000000
Sub，库存减少次数=5999484.000000
Sn，库存总额=54110.000000
Zero，库存清空次数=6734.000000
Zero_man，运行十万次以上库存清空次数=6286
Sv，日均滞销库存=0.003607
Times，随机化初始时间参数=1499500940
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.5099 seconds with return value 33
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=6001457.000000
Sta，库存不变次数=3000657.000000
Sub，库存减少次数=5997886.000000
Sn，库存总额=76100.000000
Zero，库存清空次数=6768.000000
Zero_man，运行十万次以上库存清空次数=6625
Sv，日均滞销库存=0.005073
Times，随机化初始时间参数=1499500983
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.5085 seconds with return value 33
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=5999769.000000
Sta，库存不变次数=2999330.000000
Sub，库存减少次数=6000901.000000
Sn，库存总额=59290.000000
Zero，库存清空次数=8334.000000
Zero_man，运行十万次以上库存清空次数=7902
Sv，日均滞销库存=0.003953
Times，随机化初始时间参数=1499501006
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.5085 seconds with return value 33
请按任意键继续. . .

5）

这里的日进货为120个面包

Add，库存增加次数=5998488.000000
Sta，库存不变次数=3000540.000000
Sub，库存减少次数=6000972.000000
Sn，库存总额=45270.000000
Zero，库存清空次数=6812.000000
Zero_man，运行十万次以上库存清空次数=6585
Sv，日均滞销库存=0.003018
Times，随机化初始时间参数=1499501057
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.628 seconds with return value 33
请按任意键继续. . .

10亿——

1）
这里的日进货为120个面包

Add，库存增加次数=400041610.000000
Sta，库存不变次数=200012114.000000
Sub，库存减少次数=399946276.000000
Sn，库存总额=1822100.000000
Zero，库存清空次数=2467.000000
Zero_man，运行十万次以上库存清空次数=1951
Sv，日均滞销库存=0.001822
Times，随机化初始时间参数=1499504383
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.41 seconds with return value 35
请按任意键继续. . .

2）

这里的日进货为120个面包

Add，库存增加次数=400010415.000000
Sta，库存不变次数=200013558.000000
Sub，库存减少次数=399976027.000000
Sn，库存总额=912910.000000
Zero，库存清空次数=6948.000000
Zero_man，运行十万次以上库存清空次数=6864
Sv，日均滞销库存=0.000913
Times，随机化初始时间参数=1499503700
Max,反复实验次数=1000000000.000000

3）
这里的日进货为120个面包

Add，库存增加次数=400034657.000000
Sta，库存不变次数=200027145.000000
Sub，库存减少次数=399938198.000000
Sn，库存总额=1765400.000000
Zero，库存清空次数=2817.000000
Zero_man，运行十万次以上库存清空次数=2208
Sv，日均滞销库存=0.001765
Times，随机化初始时间参数=1499504690
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.93 seconds with return value 35
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=400011094.000000
Sta，库存不变次数=200012907.000000
Sub，库存减少次数=399975999.000000
Sn，库存总额=934970.000000
Zero，库存清空次数=4023.000000
Zero_man，运行十万次以上库存清空次数=3464
Sv，日均滞销库存=0.000935
Times，随机化初始时间参数=1499504856
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.72 seconds with return value 35
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=400028633.000000
Sta，库存不变次数=200009998.000000
Sub，库存减少次数=399961369.000000
Sn，库存总额=1526240.000000
Zero，库存清空次数=19270.000000
Zero_man，运行十万次以上库存清空次数=18536
Sv，日均滞销库存=0.001526
Times，随机化初始时间参数=1499504946
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.59 seconds with return value 35
请按任意键继续. . .



1.4.实验结论

实验次数为50万、100万、500万的时候Sv上下起伏较大。而1500万次的情况下Sv几乎都在0.005以下振动，我做了50次独立实验，只有一次在0.005之上（就是列出的那次）。10亿次的实验做了10次，都在0.002之下。

另外我还跑了三次100亿，都在0.0013之下，贴一个日均剩余最大的：

这里的日进货为120个面包

Add，库存增加次数=4000250437.000000
Sta，库存不变次数=2000129855.000000
Sub，库存减少次数=3999619708.000000
Sn，库存总额=12606790.000000
Zero，库存清空次数=8699.000000
Zero_man，运行十万次以上库存清空次数=7275
Sv，日均滞销库存=0.001261
Times，随机化初始时间参数=1499505239
Max,反复实验次数=10000000000.000000

--------------------------------
Process exited after 314.8 seconds with return value 36
请按任意键继续. . .

-------------------------------

单次实验的n越大，m次实验的Sv就越接近0。根据弱大数定律可以认为日剩余均值在不断趋近它的期望。

2.2.理论依据

事件1：需求量为100、110、120的事件

事件2：需求量为130、140的事件

随机变量X=（n次实验下事件2发生的次数）。显然，事件1的概率p为60%，事件2的概率q为40%。

X满足二项分布，其标准差Sigma=sqrt（n*p*q）

Sigma/n=[sqrt(n) * sqrt(p*q)]/n=sqrt(p*q)/sqrt(n)，比值趋于0。

[sqrt(n) * sqrt(p*q)]/n——说明了标准差的增长速度慢于n的增长速度，平均到每天离散程度都是在下降的。货物总剩余是离散性造成的，不论是货物滞销还是货物累计被清空必然的结果都是货物存量上升。而标准差是离散数据离散程度的度量，有理由相信可以用【平均单日标准差】来度量【平均单日货物剩余】的程度。

这只是一个思路，恰当的定量方法还在摸索。如果此处正确，期望值是0。

作者: loy_20002000    时间: 2017-7-8 19:32
牛腰 发表于 2017-7-6 21:21
1．在供大于求的情况下销售量和需求量是相等的，如果每天都有150个面包可以出售，统计结果是销售量在100 ...

另外补充一个130、140的剩余可以统统处理成-10、-20的结果。

                else if (D==6 || D==7)
                {
                        Sub++;
                        //if(Sn>=10)
                                Sn=Sn-10;        
                }   
                else if (D= 8 || D==9)
                {
                        Sub++;
                        //if (Sn>=20)
                                Sn=Sn-20;
                        //else if (Sn<20 && Sn >=0)
                        //        Sn=0;

1500万：

这里的日进货为120个面包

Add，库存增加次数=6003427.000000
Sta，库存不变次数=2998483.000000
Sub，库存减少次数=5998090.000000
Sn，库存总额=70260.000000
Zero，库存清空次数=1801.000000
Zero_man，运行十万次以上库存清空次数=1774
Sv，日均滞销库存=0.004684
Times，随机化初始时间参数=1499510708
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.6654 seconds with return value 33
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=5999779.000000
Sta，库存不变次数=2998864.000000
Sub，库存减少次数=6001357.000000
Sn，库存总额=-31570.000000
Zero，库存清空次数=623.000000
Zero_man，运行十万次以上库存清空次数=383
Sv，日均滞销库存=-0.002105
Times，随机化初始时间参数=1499511077
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.5144 seconds with return value 33
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=5999858.000000
Sta，库存不变次数=3001357.000000
Sub，库存减少次数=5998785.000000
Sn，库存总额=42390.000000
Zero，库存清空次数=861.000000
Zero_man，运行十万次以上库存清空次数=760
Sv，日均滞销库存=0.002826
Times，随机化初始时间参数=1499511113
Max,反复实验次数=15000000.000000

--------------------------------
Process exited after 0.4997 seconds with return value 33
请按任意键继续. . .

一个亿：

这里的日进货为120个面包

Add，库存增加次数=40004956.000000
Sta，库存不变次数=20000250.000000
Sub，库存减少次数=39994794.000000
Sn，库存总额=240850.000000
Zero，库存清空次数=467.000000
Zero_man，运行十万次以上库存清空次数=42
Sv，日均滞销库存=0.002409
Times，随机化初始时间参数=1499511190
Max,反复实验次数=100000000.000000

--------------------------------
Process exited after 3.31 seconds with return value 34
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=40001063.000000
Sta，库存不变次数=19993838.000000
Sub，库存减少次数=40005099.000000
Sn，库存总额=-63950.000000
Zero，库存清空次数=3838.000000
Zero_man，运行十万次以上库存清空次数=3783
Sv，日均滞销库存=-0.000639
Times，随机化初始时间参数=1499511227
Max,反复实验次数=100000000.000000

--------------------------------
Process exited after 3.289 seconds with return value 34
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=40005208.000000
Sta，库存不变次数=20000671.000000
Sub，库存减少次数=39994121.000000
Sn，库存总额=245100.000000
Zero，库存清空次数=1182.000000
Zero_man，运行十万次以上库存清空次数=1017
Sv，日均滞销库存=0.002451
Times，随机化初始时间参数=1499511259
Max,反复实验次数=100000000.000000

--------------------------------
Process exited after 3.148 seconds with return value 34
请按任意键继续. . .

10亿：

这里的日进货为120个面包

Add，库存增加次数=400031496.000000
Sta，库存不变次数=200023806.000000
Sub，库存减少次数=399944698.000000
Sn，库存总额=1539040.000000
Zero，库存清空次数=7706.000000
Zero_man，运行十万次以上库存清空次数=7546
Sv，日均滞销库存=0.001539
Times，随机化初始时间参数=1499511772
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.5 seconds with return value 35
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=400021945.000000
Sta，库存不变次数=200006364.000000
Sub，库存减少次数=399971691.000000
Sn，库存总额=1130980.000000
Zero，库存清空次数=9151.000000
Zero_man，运行十万次以上库存清空次数=8990
Sv，日均滞销库存=0.001131
Times，随机化初始时间参数=1499511951
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.5 seconds with return value 35
请按任意键继续. . .


这里的日进货为120个面包

Add，库存增加次数=400038347.000000
Sta，库存不变次数=200009120.000000
Sub，库存减少次数=399952533.000000
Sn，库存总额=1509130.000000
Zero，库存清空次数=4657.000000
Zero_man，运行十万次以上库存清空次数=4230
Sv，日均滞销库存=0.001509
Times，随机化初始时间参数=1499512375
Max,反复实验次数=1000000000.000000

--------------------------------
Process exited after 31.36 seconds with return value 35
请按任意键继续. . .

---------------------------------------------------

显然它的期望是0，1500亿的情况下是最大剩余70260。 一个亿的时候达到了245100。单日期望为0不等于累计期望也是0，因为有标准差的存在，均值在逼近的同时标准差也是一直在增大的。10亿的时候剩余甚至可以高达库存总额=1539040.000000。

需要注意的是5种情况在这里可能不是等概率的，平均运行32767次会少两次（-20），所以当n足够大的情况下几乎只能得到正数。当然，这只是当年学计算机的时候课本上的东西，这里我的赋值是int，但取值范围好像比long还大，随机数的最大值究竟是多少我没有测试过。由于对概率及期望影响很小，这里我就不严格化了。
作者: loy_20002000    时间: 2017-7-8 20:11
牛腰 发表于 2017-7-6 21:21
1．在供大于求的情况下销售量和需求量是相等的，如果每天都有150个面包可以出售，统计结果是销售量在100 ...

想了下干脆再严格点，保证5个情况都是等概率的。测试了下随机数上限与老的c规范一样。超过32760的数字统统屏蔽。

       if (GetRam>=32760 && GetRam <=32767)
        {
            Lost++;  //记录多余的随机数个数
            i--;          //此次循环不作数，再来过
        }
       else
      {
           ……
      }
1000万的情况：

这里的日进货为120个面包

Add，库存增加次数=4001941.000000
Sta，库存不变次数=2001263.000000
Sub，库存减少次数=3996796.000000
Sn，库存总额=61950.000000
Zero，库存清空次数=303.000000
Zero_man，运行十万次以上库存清空次数=200
Sv，日均滞销库存=0.006195
Times，随机化初始时间参数=1499514945
Max,反复实验次数=10000000.000000
Lost，2481

--------------------------------
Process exited after 0.3767 seconds with return value 11
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=3998974.000000
Sta，库存不变次数=1999051.000000
Sub，库存减少次数=4001975.000000
Sn，库存总额=-52880.000000
Zero，库存清空次数=601.000000
Zero_man，运行十万次以上库存清空次数=574
Sv，日均滞销库存=-0.005288
Times，随机化初始时间参数=1499515066
Max,反复实验次数=10000000.000000
Lost，2379

--------------------------------
Process exited after 0.3534 seconds with return value 11
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=4000652.000000
Sta，库存不变次数=1997585.000000
Sub，库存减少次数=4001763.000000
Sn，库存总额=-13980.000000
Zero，库存清空次数=1845.000000
Zero_man，运行十万次以上库存清空次数=1679
Sv，日均滞销库存=-0.001398
Times，随机化初始时间参数=1499515089
Max,反复实验次数=10000000.000000
Lost，2483

--------------------------------
Process exited after 0.355 seconds with return value 11
请按任意键继续. . .

一亿：

这里的日进货为120个面包

Add，库存增加次数=39997990.000000
Sta，库存不变次数=19998299.000000
Sub，库存减少次数=40003711.000000
Sn，库存总额=-132430.000000
Zero，库存清空次数=453.000000
Zero_man，运行十万次以上库存清空次数=178
Sv，日均滞销库存=-0.001324
Times，随机化初始时间参数=1499515136
Max,反复实验次数=100000000.000000
Lost，24387

--------------------------------
Process exited after 3.365 seconds with return value 12
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=40006094.000000
Sta，库存不变次数=19995047.000000
Sub，库存减少次数=39998859.000000
Sn，库存总额=103640.000000
Zero，库存清空次数=2542.000000
Zero_man，运行十万次以上库存清空次数=2462
Sv，日均滞销库存=0.001036
Times，随机化初始时间参数=1499515171
Max,反复实验次数=100000000.000000
Lost，24452

--------------------------------
Process exited after 3.343 seconds with return value 12
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=39991077.000000
Sta，库存不变次数=20000421.000000
Sub，库存减少次数=40008502.000000
Sn，库存总额=-309440.000000
Zero，库存清空次数=4014.000000
Zero_man，运行十万次以上库存清空次数=3738
Sv，日均滞销库存=-0.003094
Times，随机化初始时间参数=1499515203
Max,反复实验次数=100000000.000000
Lost，24306

--------------------------------
Process exited after 3.233 seconds with return value 12
请按任意键继续. . .

10亿：

这里的日进货为120个面包

Add，库存增加次数=400006086.000000
Sta，库存不变次数=200012789.000000
Sub，库存减少次数=399981125.000000
Sn，库存总额=383090.000000
Zero，库存清空次数=7275.000000
Zero_man，运行十万次以上库存清空次数=7246
Sv，日均滞销库存=0.000383
Times，随机化初始时间参数=1499515377
Max,反复实验次数=1000000000.000000
Lost，243677

--------------------------------
Process exited after 32.42 seconds with return value 13
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=400006590.000000
Sta，库存不变次数=200010264.000000
Sub，库存减少次数=399983146.000000
Sn，库存总额=263110.000000
Zero，库存清空次数=23509.000000
Zero_man，运行十万次以上库存清空次数=23495
Sv，日均滞销库存=0.000263
Times，随机化初始时间参数=1499515488
Max,反复实验次数=1000000000.000000
Lost，243622

--------------------------------
Process exited after 32.06 seconds with return value 13
请按任意键继续. . .

这里的日进货为120个面包

Add，库存增加次数=400005239.000000
Sta，库存不变次数=200011735.000000
Sub，库存减少次数=399983026.000000
Sn，库存总额=325210.000000
Zero，库存清空次数=4791.000000
Zero_man，运行十万次以上库存清空次数=4683
Sv，日均滞销库存=0.000325
Times，随机化初始时间参数=1499515564
Max,反复实验次数=1000000000.000000
Lost，243722

--------------------------------
Process exited after 31.95 seconds with return value 13
请按任意键继续. . .



-----------------------------

我的结论依然成立。有趣的是原题意下的测试Lost值是很高的，但日均剩余并没有拼命累积，这是值得玩味的。如果把Lost算上，日均剩余还能再低一些。

作者: smileREGENT    时间: 2017-7-8 20:13
咳咳咳，其实高中数学也考这种题，原来做过不少。
根据“理解出题人意思”的原则，本题目的在于考察考生对于数学期望概念的理解和掌握，属于一类问题
楼上这些大触统统脑后有反骨，数学考试不及格，课后来办公室一趟
开个玩笑
作者: 牛腰    时间: 2017-7-8 21:00
loy_20002000 发表于 2017-7-8 20:11
想了下干脆再严格点，保证5个情况都是等概率的。测试了下随机数上限与老的c规范一样。超过32760的数字统 ...

你给出的这些结果里库存总额是负数的结果出现了6次，不知道是代码问题还是机器执行问题。因为客观上每天的库存都不可能出现负数，运行那么多次后Sn还为负数，我觉得你的模型的问题比较大。这个问题要先解决了才能对运行结果做结论。
作者: 视觉错误    时间: 2017-7-8 21:53
我的模拟结果同牛妖。
每天进货数量是120，次日首先销售存货，存货销售完之后才卖当天的进货。
================================================
每天进货数量 120 总天数 100000000
当前库存 45310 历史最大库存 156650
总利润 -11978124450 平均每天利润 -119.7812445
增加天数 39995537 减少天数 39993379 持平天数 20011084 卖光天数 19000
作者: Dracula    时间: 2017-7-8 22:31
刚才我用dynamic programming的方法又想了一下这个问题。解题的关键是意识到每一期的最优产量不是恒定，而是随上一期遗留下来的库存而变化，是库存的函数。你可以证明，如果库存为0的时候的最优产量是x，那么库存为y的时候的最优产量就应该是x-y（直觉上应该是挺明显，严格证明不是那么容易）。遗留给下一期的库存同从上期继承下来的库存无关（y完全被x-y抵消），上期遗留下来的库存对总体润的影响只在于本期。这样问题被大大简化。如果库存是y的话，对总利润的影响就是-y。这跟完全把它当成是个一期问题来解是等价的。因此你引的网上的那个计算方法是正确的，不管你把它当成是个一期还是个无穷期问题。

作者: loy_20002000    时间: 2017-7-8 22:41
牛腰 发表于 2017-7-8 21:00
你给出的这些结果里库存总额是负数的结果出现了6次，不知道是代码问题还是机器执行问题。因为客观上每天 ...

大哥，你很伤我的心呀。我已经说明了，要的就是负数。我求的是100、110、120、130、140几种情况下，130、140每次都得出负数剩余（-10、-20）的结果。这个变形的期望肯定是0，我旨在说明日期望等于0不等于日剩余也是0。相反的，距离0这个点很远。

下面我再跑一次原题目下的剩余。c语言随机数下140这个情况每32767次下少跑2次，n小的情况下影响不大，如果很大就会偏离很远很远。这里的结果是消除了细微概率差异的，如果c的库函数没有错的话，可以保证等概率。

50万——

1）
这里的日进货为120个面包

Add，库存增加次数=200068.000000
Sta，库存不变次数=99774.000000
Sub，库存减少次数=200158.000000
Sn，库存总额=2740.000000
Zero，库存清空次数=1167.000000
Zero_man，运行十万次以上库存清空次数=0
Sv，日均滞销库存=0.005480
Times，随机化初始时间参数=1499520955
Max,反复实验次数=500000.000000
Lost，118

--------------------------------
Process exited after 0.2152 seconds with return value 10
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=199851.000000
Sta，库存不变次数=99424.000000
Sub，库存减少次数=200725.000000
Sn，库存总额=7600.000000
Zero，库存清空次数=1878.000000
Zero_man，运行十万次以上库存清空次数=970
Sv，日均滞销库存=0.015200
Times，随机化初始时间参数=1499521065
Max,反复实验次数=500000.000000
Lost，119

--------------------------------
Process exited after 0.05965 seconds with return value 10
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=199808.000000
Sta，库存不变次数=99944.000000
Sub，库存减少次数=200248.000000
Sn，库存总额=3040.000000
Zero，库存清空次数=1925.000000
Zero_man，运行十万次以上库存清空次数=1293
Sv，日均滞销库存=0.006080
Times，随机化初始时间参数=1499521090
Max,反复实验次数=500000.000000
Lost，129

--------------------------------
Process exited after 0.04851 seconds with return value 10
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=200257.000000
Sta，库存不变次数=99701.000000
Sub，库存减少次数=200042.000000
Sn，库存总额=7080.000000
Zero，库存清空次数=784.000000
Zero_man，运行十万次以上库存清空次数=542
Sv，日均滞销库存=0.014160
Times，随机化初始时间参数=1499521123
Max,反复实验次数=500000.000000
Lost，129

--------------------------------
Process exited after 0.0474 seconds with return value 10
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=200394.000000
Sta，库存不变次数=99465.000000
Sub，库存减少次数=200141.000000
Sn，库存总额=6940.000000
Zero，库存清空次数=1103.000000
Zero_man，运行十万次以上库存清空次数=536
Sv，日均滞销库存=0.013880
Times，随机化初始时间参数=1499521167
Max,反复实验次数=500000.000000
Lost，119

--------------------------------
Process exited after 0.04788 seconds with return value 10
请按任意键继续. . .



100万——

1）
这里的日进货为120个面包

Add，库存增加次数=399353.000000
Sta，库存不变次数=200464.000000
Sub，库存减少次数=400183.000000
Sn，库存总额=8070.000000
Zero，库存清空次数=3086.000000
Zero_man，运行十万次以上库存清空次数=2763
Sv，日均滞销库存=0.008070
Times，随机化初始时间参数=1499521220
Max,反复实验次数=1000000.000000
Lost，240

--------------------------------
Process exited after 0.1991 seconds with return value 10
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=399540.000000
Sta，库存不变次数=200441.000000
Sub，库存减少次数=400019.000000
Sn，库存总额=16730.000000
Zero，库存清空次数=3700.000000
Zero_man，运行十万次以上库存清空次数=2914
Sv，日均滞销库存=0.016730
Times，随机化初始时间参数=1499521248
Max,反复实验次数=1000000.000000
Lost，243

--------------------------------
Process exited after 0.08585 seconds with return value 10
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=399857.000000
Sta，库存不变次数=200030.000000
Sub，库存减少次数=400113.000000
Sn，库存总额=12840.000000
Zero，库存清空次数=1441.000000
Zero_man，运行十万次以上库存清空次数=664
Sv，日均滞销库存=0.012840
Times，随机化初始时间参数=1499521274
Max,反复实验次数=1000000.000000
Lost，230

--------------------------------
Process exited after 0.06391 seconds with return value 10
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=401019.000000
Sta，库存不变次数=199878.000000
Sub，库存减少次数=399103.000000
Sn，库存总额=31860.000000
Zero，库存清空次数=630.000000
Zero_man，运行十万次以上库存清空次数=124
Sv，日均滞销库存=0.031860
Times，随机化初始时间参数=1499521292
Max,反复实验次数=1000000.000000
Lost，230

--------------------------------
Process exited after 0.06383 seconds with return value 10
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=399897.000000
Sta，库存不变次数=200469.000000
Sub，库存减少次数=399634.000000
Sn，库存总额=7950.000000
Zero，库存清空次数=713.000000
Zero_man，运行十万次以上库存清空次数=491
Sv，日均滞销库存=0.007950
Times，随机化初始时间参数=1499521315
Max,反复实验次数=1000000.000000
Lost，232

--------------------------------
Process exited after 0.06297 seconds with return value 10
请按任意键继续. . .

150万——

1）
这里的日进货为120个面包

Add，库存增加次数=600113.000000
Sta，库存不变次数=300358.000000
Sub，库存减少次数=599529.000000
Sn，库存总额=19050.000000
Zero，库存清空次数=1423.000000
Zero_man，运行十万次以上库存清空次数=1098
Sv，日均滞销库存=0.012700
Times，随机化初始时间参数=1499521363
Max,反复实验次数=1500000.000000
Lost，343

--------------------------------
Process exited after 0.2178 seconds with return value 10
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=599892.000000
Sta，库存不变次数=299832.000000
Sub，库存减少次数=600276.000000
Sn，库存总额=8360.000000
Zero，库存清空次数=2230.000000
Zero_man，运行十万次以上库存清空次数=1981
Sv，日均滞销库存=0.005573
Times，随机化初始时间参数=1499521384
Max,反复实验次数=1500000.000000
Lost，389

--------------------------------
Process exited after 0.208 seconds with return value 10
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=600715.000000
Sta，库存不变次数=299758.000000
Sub，库存减少次数=599527.000000
Sn，库存总额=30100.000000
Zero，库存清空次数=1044.000000
Zero_man，运行十万次以上库存清空次数=858
Sv，日均滞销库存=0.020067
Times，随机化初始时间参数=1499521403
Max,反复实验次数=1500000.000000
Lost，374

--------------------------------
Process exited after 0.09633 seconds with return value 10
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=599690.000000
Sta，库存不变次数=300519.000000
Sub，库存减少次数=599791.000000
Sn，库存总额=12730.000000
Zero，库存清空次数=1783.000000
Zero_man，运行十万次以上库存清空次数=1723
Sv，日均滞销库存=0.008487
Times，随机化初始时间参数=1499521426
Max,反复实验次数=1500000.000000
Lost，344

--------------------------------
Process exited after 0.0784 seconds with return value 10
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=599414.000000
Sta，库存不变次数=300800.000000
Sub，库存减少次数=599786.000000
Sn，库存总额=19150.000000
Zero，库存清空次数=3658.000000
Zero_man，运行十万次以上库存清空次数=3179
Sv，日均滞销库存=0.012767
Times，随机化初始时间参数=1499521462
Max,反复实验次数=1500000.000000
Lost，349

--------------------------------
Process exited after 0.0794 seconds with return value 10
请按任意键继续. . .

1500万——

1）
这里的日进货为120个面包

Add，库存增加次数=5998038.000000
Sta，库存不变次数=3000758.000000
Sub，库存减少次数=6001204.000000
Sn，库存总额=15070.000000
Zero，库存清空次数=5500.000000
Zero_man，运行十万次以上库存清空次数=4551
Sv，日均滞销库存=0.001005
Times，随机化初始时间参数=1499521522
Max,反复实验次数=15000000.000000
Lost，3660

--------------------------------
Process exited after 0.6329 seconds with return value 11
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=5997332.000000
Sta，库存不变次数=3000891.000000
Sub，库存减少次数=6001777.000000
Sn，库存总额=20950.000000
Zero，库存清空次数=8966.000000
Zero_man，运行十万次以上库存清空次数=8560
Sv，日均滞销库存=0.001397
Times，随机化初始时间参数=1499521544
Max,反复实验次数=15000000.000000
Lost，3649

--------------------------------
Process exited after 0.5285 seconds with return value 11
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=6000321.000000
Sta，库存不变次数=2998559.000000
Sub，库存减少次数=6001120.000000
Sn，库存总额=23020.000000
Zero，库存清空次数=7636.000000
Zero_man，运行十万次以上库存清空次数=7295
Sv，日均滞销库存=0.001535
Times，随机化初始时间参数=1499521575
Max,反复实验次数=15000000.000000
Lost，3669

--------------------------------
Process exited after 0.5051 seconds with return value 11
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=5997993.000000
Sta，库存不变次数=2998745.000000
Sub，库存减少次数=6003262.000000
Sn，库存总额=6420.000000
Zero，库存清空次数=14458.000000
Zero_man，运行十万次以上库存清空次数=14214
Sv，日均滞销库存=0.000428
Times，随机化初始时间参数=1499521598
Max,反复实验次数=15000000.000000
Lost，3614

--------------------------------
Process exited after 0.5063 seconds with return value 11
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=5998799.000000
Sta，库存不变次数=3001690.000000
Sub，库存减少次数=5999511.000000
Sn，库存总额=53140.000000
Zero，库存清空次数=7685.000000
Zero_man，运行十万次以上库存清空次数=7246
Sv，日均滞销库存=0.003543
Times，随机化初始时间参数=1499521618
Max,反复实验次数=15000000.000000
Lost，3749

--------------------------------
Process exited after 0.504 seconds with return value 11
请按任意键继续. . .

一亿——

1）
这里的日进货为120个面包

Add，库存增加次数=40004207.000000
Sta，库存不变次数=20001767.000000
Sub，库存减少次数=39994026.000000
Sn，库存总额=167190.000000
Zero，库存清空次数=1311.000000
Zero_man，运行十万次以上库存清空次数=1026
Sv，日均滞销库存=0.001672
Times，随机化初始时间参数=1499521680
Max,反复实验次数=100000000.000000
Lost，24358

--------------------------------
Process exited after 3.327 seconds with return value 12
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=40006750.000000
Sta，库存不变次数=20003254.000000
Sub，库存减少次数=39989996.000000
Sn，库存总额=237090.000000
Zero，库存清空次数=720.000000
Zero_man，运行十万次以上库存清空次数=278
Sv，日均滞销库存=0.002371
Times，随机化初始时间参数=1499521719
Max,反复实验次数=100000000.000000
Lost，24552

--------------------------------
Process exited after 3.193 seconds with return value 12
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=39997922.000000
Sta，库存不变次数=20002488.000000
Sub，库存减少次数=39999590.000000
Sn，库存总额=29280.000000
Zero，库存清空次数=12577.000000
Zero_man，运行十万次以上库存清空次数=12281
Sv，日均滞销库存=0.000293
Times，随机化初始时间参数=1499521783
Max,反复实验次数=100000000.000000
Lost，24719

--------------------------------
Process exited after 3.242 seconds with return value 12
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=39993865.000000
Sta，库存不变次数=20003723.000000
Sub，库存减少次数=40002412.000000
Sn，库存总额=32030.000000
Zero，库存清空次数=22246.000000
Zero_man，运行十万次以上库存清空次数=22006
Sv，日均滞销库存=0.000320
Times，随机化初始时间参数=1499521812
Max,反复实验次数=100000000.000000
Lost，24246

--------------------------------
Process exited after 3.187 seconds with return value 12
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=39995742.000000
Sta，库存不变次数=20001729.000000
Sub，库存减少次数=40002529.000000
Sn，库存总额=15170.000000
Zero，库存清空次数=10982.000000
Zero_man，运行十万次以上库存清空次数=10619
Sv，日均滞销库存=0.000152
Times，随机化初始时间参数=1499521837
Max,反复实验次数=100000000.000000
Lost，24307

--------------------------------
Process exited after 3.203 seconds with return value 12
请按任意键继续. . .

十亿——

1）
这里的日进货为120个面包

Add，库存增加次数=400016354.000000
Sta，库存不变次数=199997642.000000
Sub，库存减少次数=399986004.000000
Sn，库存总额=528820.000000
Zero，库存清空次数=22302.000000
Zero_man，运行十万次以上库存清空次数=21977
Sv，日均滞销库存=0.000529
Times，随机化初始时间参数=1499521928
Max,反复实验次数=1000000000.000000
Lost，244112

--------------------------------
Process exited after 31.66 seconds with return value 13
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=399990651.000000
Sta，库存不变次数=199993791.000000
Sub，库存减少次数=400015558.000000
Sn，库存总额=188010.000000
Zero，库存清空次数=73797.000000
Zero_man，运行十万次以上库存清空次数=72678
Sv，日均滞销库存=0.000188
Times，随机化初始时间参数=1499521981
Max,反复实验次数=1000000000.000000
Lost，244123

--------------------------------
Process exited after 31.59 seconds with return value 13
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=399990270.000000
Sta，库存不变次数=199991517.000000
Sub，库存减少次数=400018213.000000
Sn，库存总额=239160.000000
Zero，库存清空次数=81648.000000
Zero_man，运行十万次以上库存清空次数=80733
Sv，日均滞销库存=0.000239
Times，随机化初始时间参数=1499522033
Max,反复实验次数=1000000000.000000
Lost，244602

--------------------------------
Process exited after 31.86 seconds with return value 13
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=399990983.000000
Sta，库存不变次数=199985547.000000
Sub，库存减少次数=400023470.000000
Sn，库存总额=76000.000000
Zero，库存清空次数=79920.000000
Zero_man，运行十万次以上库存清空次数=79815
Sv，日均滞销库存=0.000076（首个5零开头）
Times，随机化初始时间参数=1499522085
Max,反复实验次数=1000000000.000000
Lost，244810

--------------------------------
Process exited after 31.75 seconds with return value 13
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=400002599.000000
Sta，库存不变次数=200002255.000000
Sub，库存减少次数=399995146.000000
Sn，库存总额=155750.000000
Zero，库存清空次数=16297.000000
Zero_man，运行十万次以上库存清空次数=16050
Sv，日均滞销库存=0.000156
Times，随机化初始时间参数=1499522204
Max,反复实验次数=1000000000.000000
Lost，244211

--------------------------------
Process exited after 31.77 seconds with return value 13
请按任意键继续. . .

一百亿——

1）
这里的日进货为120个面包

Add，库存增加次数=4000020809.000000
Sta，库存不变次数=1999995659.000000
Sub，库存减少次数=3999983532.000000
Sn，库存总额=685930.000000
Zero，库存清空次数=17216.000000
Zero_man，运行十万次以上库存清空次数=16908
Sv，日均滞销库存=0.000069
Times，随机化初始时间参数=1499522324
Max,反复实验次数=10000
000000.000000
Lost，2441718

--------------------------------
Process exited after 318.4 seconds with return value 14
请按任意键继续. . .

2）
这里的日进货为120个面包

Add，库存增加次数=4000010563.000000
Sta，库存不变次数=2000006660.000000
Sub，库存减少次数=3999982777.000000
Sn，库存总额=652210.000000
Zero，库存清空次数=33915.000000
Zero_man，运行十万次以上库存清空次数=33588
Sv，日均滞销库存=0.000065
Times，随机化初始时间参数=1499522733
Max,反复实验次数=10000000000.000000
Lost，2441539

--------------------------------
Process exited after 317.4 seconds with return value 14
请按任意键继续. . .

3）
这里的日进货为120个面包

Add，库存增加次数=3999987212.000000
Sta，库存不变次数=1999992452.000000
Sub，库存减少次数=4000020336.000000
Sn，库存总额=174280.000000
Zero，库存清空次数=79800.000000
Zero_man，运行十万次以上库存清空次数=79581
Sv，日均滞销库存=0.000017
Times，随机化初始时间参数=1499523129
Max,反复实验次数=10000000000.000000
Lost，2442276

--------------------------------
Process exited after 320.5 seconds with return value 14
请按任意键继续. . .

4）
这里的日进货为120个面包

Add，库存增加次数=3999990358.000000
Sta，库存不变次数=1999992636.000000
Sub，库存减少次数=4000017006.000000
Sn，库存总额=264380.000000
Zero，库存清空次数=81089.000000
Zero_man，运行十万次以上库存清空次数=79913
Sv，日均滞销库存=0.000026
Times，随机化初始时间参数=1499523514
Max,反复实验次数=10000000000.000000
Lost，2442516

--------------------------------
Process exited after 318.6 seconds with return value 14
请按任意键继续. . .

5）
这里的日进货为120个面包

Add，库存增加次数=3999986666.000000
Sta，库存不变次数=1999996160.000000
Sub，库存减少次数=4000017174.000000
Sn，库存总额=252540.000000
Zero，库存清空次数=89638.000000
Zero_man，运行十万次以上库存清空次数=89312
Sv，日均滞销库存=0.000025
Times，随机化初始时间参数=1499523866
Max,反复实验次数=10000000000.000000
Lost，2442352

--------------------------------
Process exited after 321.3 seconds with return value 14
请按任意键继续. . .

------------------------------------------------

最终结论：

1.我对期望为0的猜测看来是正确的。100亿次重复实验下，每次都是5个零打头。

2.用标准差与n的比值来度量【日均离散程度】是合理的。f（n）=sqrt(n)*sqrt（p*q），g(n)=n，由于g（n）增长更快，所以这个比值一定是逐渐逼近0的。

3.没想到小小的误差居然会造成两次检验结果的巨大差异。如果第一次检验我把误差消除掉早得到最终结果了。以此为戒！！！

----------------------------------------------


附最终版代码：



#include <stdlib.h>
#include <stdio.h>
#include <time.h>           //使用当前时钟做种子


double i, S0,Add,Sub,Sta,Sn,Zero,Max,Sv;
        //
int D,GetRam,Times,Zero_man,Lost;        //man==万       


                               


void main( void )
{       
       
        S0=0;
        Sn=S0;
        Add=0;
        Sub=0;
        Sta=0;
        GetRam=0;
        D=0;
        Zero=0;
        Max=10000000000;
        Times=0;
        Zero_man=0;
        Lost=0;
       
        srand( Times=(unsigned)time( NULL ) );  
       
       
    for( i = 0; i < Max;i++ )                          
    {
                GetRam=rand();
                D=GetRam%10;
               
                if (GetRam>=32760 && GetRam <=32767)
                {
                        Lost++;
                        i--;
                }               
                else
                {                                         //printf("D=%d\n",D);
               
                if (D==0 || D==1)
                        {
                                Add++;
                                Sn=Sn+20;
                       
                    }
                else if (D==2 || D==3)
                        {
                                Add++;
                                Sn=Sn+10;
                        }
                else if (D==4 || D==5)
                        {
                                Sta++;
                                Sn=Sn+0;
                        }   
                else if (D==6 || D==7)
                        {
                                Sub++;
                                if(Sn>=10)
                                        Sn=Sn-10;       
                        }   
                else if (D= 8 || D==9)
                        {
                                Sub++;
                                if (Sn>=20)
                                        Sn=Sn-20;
                                else if (Sn<20 && Sn >=0)
                                        Sn=0;
                        }                     
            if(Sn==0)
                    {
                                Zero++;
                                if(i>=100000)
                                        Zero_man++;
                               
                        }
               
                       
                }
       
        }                                                  // rand() 0~65535 32767
                
        Sv=Sn/Max;
               
        printf("这里的日进货为120个面包\n\n");
        printf("Add，库存增加次数=%f\n",Add);
        printf("Sta，库存不变次数=%f\n",Sta);
        printf("Sub，库存减少次数=%f\n",Sub);       
        printf("Sn，库存总额=%f\n",Sn) ;       
        printf("Zero，库存清空次数=%f\n",Zero);
        printf("Zero_man，运行十万次以上库存清空次数=%d\n",Zero_man);
        printf("Sv，日均滞销库存=%f\n",Sv);        
        printf("Times，随机化初始时间参数=%d\n",Times);
        printf("Max,反复实验次数=%f\n",Max);
        printf("Lost，%d\n",Lost);       
                
}
作者: loy_20002000    时间: 2017-7-8 22:58
视觉错误 发表于 2017-7-8 21:53
我的模拟结果同牛妖。
每天进货数量是120，次日首先销售存货，存货销售完之后才卖当天的进货。
=========== ...

注意楼主给出的图表，按照那个处理只有将滞销货处理给第三方才成立。而这个题目是系统分析师考试的1分题，就是简单的考期望。

如果追求的是利益最大化，显然商家不会蠢到先卖滞销货再卖新鲜货。按先卖新鲜面包再卖滞销货的策略或处理给第三方的做法，120才是最佳选择。

这楼我给出多少个模拟结果我都数不清了，你可以看看。滞销货哪怕全部卖不出去对利润的影响也是微乎其微的，平均到每天就是可以忽略的量（120情况下）。
作者: 牛腰    时间: 2017-7-9 00:01
本帖最后由 牛腰 于 2017-7-9 00:07 编辑
loy_20002000 发表于 2017-7-8 22:41
大哥，你很伤我的心呀。我已经说明了，要的就是负数。我求的是100、110、120、130、140几种情况下，130、 ...


我的天，为了这个你就伤心了

库存量每一天的变化可能是-10或-20，但是库存（Sn）本身的值不可能是负的！你前面给的像

Sn，库存总额=-31570.000000

这样的结果不可能是对的。这个概念上的差别你明白吗？


还有你的代码为什么要D=GetRam%10？D=GetRam%5 可以得到同样的效果，你就不需要if后面加那么多“||”了。不过这个只影响代码效率，不影响结果。
作者: loy_20002000    时间: 2017-7-9 00:26
本帖最后由 loy_20002000 于 2017-7-9 00:39 编辑
牛腰 发表于 2017-7-9 00:01
我的天，为了这个你就伤心了

库存量每一天的变化可能是-10或-20，但是库存（Sn）本身的值不可能是负 ...

偶的神呐，我说的可不是原题目呀。加上这次，强调三次了。

还有你的代码为什么要D=GetRam%10？D=GetRam%5 可以得到同样的效果，你就不需要if后面加那么多“||”了。不过这个只影响代码效率，不影响结果。

真没注意，我为什么要这么干呢？等我好好想一想。是啊，我怎么发明这么一个奇怪的玩意儿，还弄得第一次模拟出现偏差。

——————————————————————

我想起来了。我怀疑标准C给的模拟不精确，如果只看0——4，我怕这四个数不是均匀分布。把10个数字都用上，概率更接近20%。
作者: 牛腰    时间: 2017-7-9 00:47
loy_20002000 发表于 2017-7-9 00:26
偶的神呐，我说的可不是原题目呀。加上这次，强调三次了。

如果允许负库存，就不存在lost sales，那你实际上就是在模拟需求量而不是销售量。这个一开始就都知道是每天120，我们不同意的地方是销售量，不是需求量。这个概念的差别我说了几次了？
作者: 牛腰    时间: 2017-7-9 02:14
本帖最后由 牛腰 于 2017-7-9 02:15 编辑
loy_20002000 发表于 2017-7-9 00:26
偶的神呐，我说的可不是原题目呀。加上这次，强调三次了。


把前面给过的例子在重复一下：假设日进120个面包，第一天的需求是140，第二天是100。第一天只卖出120个，lost sales=20，剩余库存为0。第二天卖出100个，满足所有需求，剩余库存为20。这样两天一共有240需求（每天120），共进货240，卖出220，lost sales=最后库存=20。

如果允许负库存，那么第一天最后库存是120-140=-20，第二天最后库存是-20+120-100=0。那么共有240需求，共进货240，最后库存是0，那么这两天一共卖出多少？
作者: loy_20002000    时间: 2017-7-9 13:56
牛腰 发表于 2017-7-9 02:14
把前面给过的例子在重复一下：假设日进120个面包，第一天的需求是140，第二天是100。第一天只卖出120个， ...

第四次强调。第一次贴出来我给出了修改后的代码，我的用意应该是一目了然的。你没仔细看呀。

我设置负库存的用意是检验期望为0的情况下，当实验次数n足够大，实际的累积库存是否为0。此为问题3。

而源头是我们最初的讨论，即你认为原题意下累积库存不断增加，所以日均库存不可能逼近于0；而我认为即便存在130、140情况下的0库存导致无法消掉多余库存，最终库存概率累积的情况，日均库存依然逼近于0。此为问题2。问题2在我的两个回复中已经给出答案了，即可以无限逼近于0。最具有说服力的是最后5个100亿次模拟，都是5个0打头，并且数据稳定性很好。我给出了一个理论依据，经过我的计算，它粗略符合。但样本误差的定量化描述目前不得而知。

而我给绿葱头最早的回复是库存总是能够被清空的，你认为无法清空会不断累积。由于清空现象的发现，这个问题已经有答案了，即无论库存多么大，总是在某个节点能够被清空。如果降价货物一直是每个3元的价值，那么总有一天它们能被清空，然后从0累积。此为问题1。问题1的残留问题是清空的密度分布，例如随着时间的推移是清空频率逐渐增加还是逐渐减少，或是清空间隔k是相对恒定的等等。由于需要用到回归分析的技巧，我不擅长所以这个我没做。

之所以提问题3是对问题2的进一步澄清。即期望为0的情况下，货物累积是可以很大的。这也印证了我前面的说法，即剩余的日均值可以无穷接近0，但累计剩余是可以为任意大数的。如一亿次重复实验下，最大剩余（最大偏离）-309440.000000，累计偏移17425次；10亿次下居然达到383090.000000，累计偏移24961次。

显然在期望必定为0的情况下尚且有如此之大的偏移现象。原题意下，货物剩余足够大所以期望不是0的论证是错误的；在这里货物剩余同样很大，但期望却是0。

那么到这里讨论是否结束了呢？没有！

虽然我反复运行了200次以上的模拟，但我怀疑其真理性。理由就是计算机生成的随机数是假随机，虽然我用时间变量初始化，但它还是假随机。样本数量达到100万以上结果的稳定性应该是很有保证的，但事实是要达到1500万以上它才具有稳定性。很多年前听说计算机随机数的分布有类似正态分布的特征，期望应该是每个数字输出都是等概率的，这里是1/32767；抽样标准差应该满足中心极限定律。由于所有的随机数生成都是抽样，所以n越大标准差越小。这也就解释了为什么1500万以下稳定性极差的原因。虽然1500万以上稳定性较好，但其输出数据依然与我的期待相差甚远！具体为什么就要深究数论的随机数算法与其他理论了，这里没法做深究。我建议你也检查下你的随机数算法是否有问题，你给出的结果拟合度太高，有可能是每次生成的随机数都是固定的。

这个论证想要解出正确解只有得到真正的随机数，但我知道的随机数列表是有限的，没法满足100亿的检验规模（也可能是我不知道）。或是用量子计算机检验，但那个几乎是没有可能性的。这个问题的关键是随机，没有真随机一切都是枉然。本来我不想机器检验的，实在是没招了。

我的检验不具有真理性。只是在大家用同一个框架处理的情况下我的结果正确。
作者: 牛腰    时间: 2017-7-10 01:29
本帖最后由 牛腰 于 2017-7-10 20:25 编辑
loy_20002000 发表于 2017-7-9 13:56
第四次强调。第一次贴出来我给出了修改后的代码，我的用意应该是一目了然的。你没仔细看呀。

我设置负 ...


如果库存的日均积累趋向一个正数，那么库存肯定趋向无穷。如果日均积累如你所说趋向0，其实啥都不能证明。假设库存是sqrt(n)或ln(n)，日均积累会趋向0，但是库存还是趋向无穷。所以模拟日均积累只能证明库存趋向无穷（日均库存积累趋向某个正数），但是不能否定这个结论。要证明“滞销面包总能买完”还得想其它办法。

换一个思路：

1. 因为库存会保留到第二天但是需求不会，由于这个不对称性，lost sales的积累导致（实际上是等于）库存的积累。举例：如果在前n天里需求量正好是120n，那么第n天的最后库存等于前n天内每一天的lost sales之和。By the way，用最后库存/总天数来估计日均lost sales积累只有在模拟的日均需求量正好是120的时候才是准确的。

2. lost sales的积累只能发生在最后库存为0的那几天，换句话说如果最后库存大于0，lost sales总数在那一天是不会增加的。

3. 每次库存清空，lost sales要么增加至少10，要么不增加。清空的话有下面几种可能：
开始库存=0，需求=120，lost sales+0
开始库存=0，需求=130，lost sales+10
开始库存=10，需求=130，lost sales+0
开始库存=0，需求=140，lost sales+20
开始库存=10，需求=140，lost sales+10
开始库存=20，需求=140，lost sales+0

如果以上几种可能概率相等，那么每次清空lost sales要增加40/6= ~6。

现在假设存在一个正数N，每次库存清空后在连续的N天内库存总会再清空一次。lost sales以每次6个面包的速度增加。那么K次清空后库存量就会以6K的幅度震荡，离再次清空的间隔也会增加。当震荡幅度超过20N时在以后的N天内库存是不可能归零的。所以N不存在，相邻两次库存清空的间隔应该是越来越长。

另外如果清空的间隔的增长和K是线性关系，那么库存震荡和K是线性关系，而总天数和K平方是线性关系。所以（1）库存震荡的幅度增长没有上限，（2）日均库存积累趋于0，而且速度和1/sqrt（天数）成正比，和试验误差类似（3）任意大的库存量被清空的概率趋于0，但是只要天数足够大，概率还是大于0（4）库存清空的间隔随着震荡幅度增加而增加，同样没有上限（5）库存清空的次数也没有上限。

如果你同意以上5点，那么“滞销面包总能被卖完”这个问题取决于“总能被卖完”的严格定义。不能简单地以是或不是回答。
作者: loy_20002000    时间: 2017-7-10 23:43
本帖最后由 loy_20002000 于 2017-7-13 02:15 编辑
牛腰 发表于 2017-7-10 01:29
如果库存的日均积累趋向一个正数，那么库存肯定趋向无穷。如果日均积累如你所说趋向0，其实啥都不能证明 ...

1.总剩余的变化曲线

[attach]71594[/attach]

这类曲线是不能说趋近于无穷的，所以货物剩余不是趋于无穷。

[attach]71596[/attach]

这是货物剩余可以一直处理成20、10、0、-10、-20的图。显然130、140造成的概率累积只是货物剩余震荡性增大的一个原因。没有概率累积，货物剩余也会一直震荡性增大。由中心极限定理可知日均剩余的标准差逐渐趋于0；而总剩余的标准差却一直在加大，这也许是剩余震荡性增大的最重要原因。

我们来看一些实验数据。

单次实验样本量：10亿
实验次数：10次
10亿次实验下增加库存次数（或减少）的标准差：15492
以下结果的偏差均在二项分布的+-两个标准差内。

1.1.库存允许取负的一些数据

库存总额                  库存清空次数                 最后一次清零的位置
-388910                  44906                            547393186
-552560                  703                                5264460
92510                     35014                             979978108
-521370                  13677                             62136719
-237520                  12556                             326917705
-392720                  1134                               1381291           
317800                    7470                               241483280
365660                    13743                             355761312  
-128410                   6006                               6191871
501290                   4101                               7908083

---------------------------
绝对值下的平均库存总量（偏移量）：349875！
这里取绝对值才能看出偏移量。

平均库存清空：13931
最后一次清零的最大清零位置：979978108
最后一次清零的最小清零位置：1381291

1.2.原题意

库存总额                  库存清空次数                 最后一次清零的位置
89650                      22886                            211267268
517130                    12048                            21105402
338350                    61807                            132512277
160270                    92858                            766267737
105470                    85660                            274988956
101020                    58987                            932244728
447730                    4603                              10738962
39840                      68586                            995175908
401190                    10652                            24394642
134130                    71354                            944329692

-----------------------
平均库存总量（偏移量）：233478
平均库存清空：48944
最后一次清零的最大清零位置：944329692
最后一次清零的最小清零位置：10738962

1.3.切比雪夫不等式

[attach]71597[/attach]

这里的标准差在2个以内，随机变量落在这个范围至少有75%的概率。也就是说1.1.）1.2.）落在至少75%的取值区间内。

1.1.）居然出现了第1381291次实验后就不再清零的情况。1.2.）也出现了第10738962次实验后就不再清零的情况。最意外的是1.1.）的平均偏移量居然比1.2.）大！

我们再来看一个极端情况，1.1.）如果发生正好两个标准差的偏移，库存增加与库存减少都偏离期望4亿两个标准差，那么货物剩余会是多少呢。

库存增加的次数=400,000,000+30984
库存减少的次数=400,000,000- 30984
货物剩余=929520

由此可见，u-2Sigma<X<u+2Sigma的最大剩余为929520。

1.4.结论

标准差是sqrt(n*p*q)，增长是O（sqrt（n））。清零的概率累积导致增长规模据猜测没有达到O（sqrt（n））。目前无结论，人果然只愿意看到自己愿意看到的东西。原始结论是站不住脚的。





2.总能被卖完的理解

最准确的说法是：【总有一天能卖完，但不是经常能卖完】。我的看法是清空的规律至今未知。

贴几个数据：

1）当167644890的最大清零间隔发生后有一个大爆发，但396636899后就再也没有清空过。

Dist_max,最大清零间隔=167644890.000000
Dist_max_u，最大清零间隔上限=184821635.000000
Dist_max_d，最大清零间隔下限=17176745.000000
Dist_max_f，最大清零间隔之前清零次数=3022.000000
Dist_max_a，最大清零间隔之后清零次数=81264.000000
Max_brother，最大清零间隔出现次数=0.000000
Last_dist，最后一次清零到运行结束检验次数=603363101.000000
Last_zero，最后一次清零的位置=396636899.000000

2）由于增加库存的频率更高，运行了10亿次居然694412后就没有清零过。囧。

Dist_max,最大清零间隔=316728.000000
Dist_max_u，最大清零间隔上限=318915.000000
Dist_max_d，最大清零间隔下限=2187.000000
Dist_max_f，最大清零间隔之前清零次数=89.000000
Dist_max_a，最大清零间隔之后清零次数=1030.000000
Max_brother，最大清零间隔出现次数=0.000000
Last_dist，最后一次清零到运行结束检验次数=999305588.000000
Last_zero，最后一次清零的位置=694412.000000

3）最大间隔出现后来了个巨大爆发，可31594173后就停住了。

Dist_max,最大清零间隔=15501412.000000
Dist_max_u，最大清零间隔上限=15873991.000000
Dist_max_d，最大清零间隔下限=372579.000000
Dist_max_f，最大清零间隔之前清零次数=2375.000000
Dist_max_a，最大清零间隔之后清零次数=14946.000000
Max_brother，最大清零间隔出现次数=0.000000
Last_dist，最后一次清零到运行结束检验次数=968405827.000000
Last_zero，最后一次清零的位置=31594173.000000

4）

Dist_max,最大清零间隔=12126585.000000
Dist_max_u，最大清零间隔上限=37863249.000000
Dist_max_d，最大清零间隔下限=25736664.000000
Dist_max_f，最大清零间隔之前清零次数=22891.000000
Dist_max_a，最大清零间隔之后清零次数=12125.000000
Max_brother，最大清零间隔出现次数=0.000000
Last_dist，最后一次清零到运行结束检验次数=944546734.000000
Last_zero，最后一次清零的位置=55453266.000000

从上可以得出一个结论，越到后面清零的可能性越小，可马上就得到了一个不同的数据。

5）爆了一个696661594的最大清零间隔后到877943333，每2165次清空一次；而最大清零之前每2817次才清空一次。

Dist_max,最大清零间隔=696661594.000000
Dist_max_u，最大清零间隔上限=741605134.000000
Dist_max_d，最大清零间隔下限=44943540.000000
Dist_max_f，最大清零间隔之前清零次数=15957.000000
Dist_max_a，最大清零间隔之后清零次数=62960.000000
Max_brother，最大清零间隔出现次数=0.000000
Last_dist，最后一次清零到运行结束检验次数=122056667.000000
Last_zero，最后一次清零的位置=877943333.000000

局部的密度分布，目前还未知。只知道清空次数的增长逐渐变缓。
作者: dynthia    时间: 2017-7-11 03:27
本帖最后由 dynthia 于 2017-7-10 14:03 编辑
loy_20002000 发表于 2017-7-10 09:43
1.总剩余的变化曲线


我觉得可以大概推导一下，不一定要算清零什么的吧。

前面 @牛腰 说了，在日期t，新增利润是Dp[t]=min(x[t],z[t]-y[t-1])-y[t-1]，其中x[t]是进货量，z[t]是当日需求，按题目是在100，110，120，130，140五个值中均匀分布，y[t-1]是前一天的滞销量。累积利润是p[t]=p[t-1]+Dp[t]。同时，有y[t]=max(y[t-1]+x[t]-z[t],0)。

所以，我们有E(p[t]|p[0],...p[t-1],y[0],...,y[t-1])=E(p[t]|p[t-1],y[t-1])=p[t-1]+E(min(x[t],z[t]-y[t-1])-y[t-1])=p[t-1]+E(min(x[t]-y[t-1],z[t]-2*y[t-1])) 。另外，p[0]=0。

我们可以看出，如果x[t]是120，130，或140，由于E(z[t])=120而且y[t]永远非负，最后的结果大约都是（这里交换了E和min，我知道不能交换，但就是“大概”推导一下吧）

E(p[t])=sum_{k from 0 to t-1} 120-2*E(y[k])

考虑到x[t]变大会导致E(y[t])变大（不用详细推导了吧），可见x[t]=120肯定强于130和140。

如果x[t]=110，则是（也交换了E和min）

E(p[t])=sum_{k from 0 to t-1} min(110-E(y[k]),120-2*E(y[k]))

可以看出，除非在x[t]=110的情况下的E(y[k])持续大于x[t]=120的情况下的E(y[k])，或两种情况下的E(y[k])同时持续小于10，x[t]=110不可能比x[t]=120差。

现在来看一下y[t]。

容易得出E(y[t]|y[0],...,y[t-1]=E(y[t]|y[t-1])，即y[t]是一个马尔柯夫过程。

如果x[t]=120，则E(y[t]|y[t-1]=0)=6, E(y[t]|y[t-1]=10)=12, E(y[t]|y[t-1]=其它值)=y[t-1]，所以在这种情况下y[t]是一个submartingale。

如果x[t]=110，则E(y[t]|y[t-1]=0)=2, E(y[t]|y[t-1]=10)=6, E(y[t]|y[t-1]=20)=12, E(y[t]|y[t-1]=其它值)=y[t-1]-10，所以在这种情况下y[t]几乎是一个supermartingale。

下面再推算似乎就很麻烦了，但从这个状态转换情况来看，很难想象x[t]=110的情况下的E(y[k])会持续大于x[t]=120的情况下的E(y[k])，似乎只有可能会持续小于它，也很难想象x[t]=120的情况下的E(y[k])会持续小于10。

所以x[t]=110应该比120强。
作者: loy_20002000    时间: 2017-7-11 20:01
本帖最后由 loy_20002000 于 2017-7-11 20:52 编辑
dynthia 发表于 2017-7-11 03:27
我觉得可以大概推导一下，不一定要算清零什么的吧。

前面 @牛腰 说了，在日期t，新增利润是Dp[t]=min(x[ ...

1.你的条理没有牛妖清晰。你给出Dp[t]=min(x[t],z[t]-y[t-1])-y[t-1]，我默认你赞成牛妖的处理方式。

1.1.100、110、120、130、140在120的进货下亏损为20、10、0、-10、-20。

1.2.显然20、10与-10、-20对冲，所以货物剩余在某个时刻必定为0。

1.3.这里的问题是先卖滞销货能否做到对冲，为简化起见，只取100、120、140，日进货120。这里当日亏损当日清，亏损=今日滞销数。

如下例。

第一日需求100，亏损20

第二日需求100，新面包销售量=100-20=80，亏损=120-80=40

最优情况下，两次140仅能对冲掉40的亏损。而两次100的亏损是60。显然时间增大亏损会不断增加。

1.4.当亏损达到140up，最低值为150的时候，当日无论销售多少货物一定是亏损=进货量。

由上：120肯定会亏损，130、140更加严重，110就算不盈利亏损也是最小的。牛妖的假设下110是正解。



2.为何120下优先售出滞销货必定负利润

你假定了货物剩余[t]是马尔科夫过程，然后还估算了转换期望。这是把简单问题复杂化了。

首先来讲滞销货肯定会在某个时刻清空，既然如此为何还会是负利润。实例分析吧。

2.1.优先卖新鲜面包

连续发生两次100，剩余40，亏损40。

2.2.优先卖滞销面包

连续发生两次100，剩余40，亏损60。

显然，滞销货挤占了新鲜货的销售量。

2.3.换个角度

货物剩余[t]换成单日亏损[t]就清楚明白了。设货物剩余[t-2]=1000，那么亏损[t-1]、亏损[t]、亏损[t+1]必定为120。t的亏损不仅仅与t-1有关，还与t-k有关，马尔科夫过程是不适用的。
作者: dynthia    时间: 2017-7-11 20:33
我没有说亏损是马尔柯夫过程，只说了剩余是马尔柯夫过程。

由于120的情况下货物剩余是马尔柯夫过程，且是submartingale，且容易推出其在某个时刻达到20或以上的概率是1，而且可推算出第一个这样的时刻的期望值不是很高，我们可以使用optional stopping theorem来判定长期来看货物剩余的期望应在20以上（虽然时时也能清空），而110的情况下剩余几乎是supermartingale，这就是为什么120的情况下利润不如110。
作者: loy_20002000    时间: 2017-7-11 21:33
dynthia 发表于 2017-7-11 20:33
我没有说亏损是马尔柯夫过程，只说了剩余是马尔柯夫过程。

由于120的情况下货物剩余是马尔柯夫过程，且是s ...

这只是一道简单的期望题而已，我只是提醒你用亏损的思路更加简洁。原回复的序号是混乱的，改了下明确了。

你、牛妖、视觉印象都假设题意的第二天3元处理掉==优先卖滞销货。按你们的假设，>=120是不可能行得通的，理由是牛妖反复强调的不对称性。但没人规定必须优先卖滞销货，也可以优先卖新鲜货，新鲜货与滞销货同时上架（这个是最符合实际的）。楼主的问题是滞销货对明日销量的影响，但他并没有明确说明是何种影响，或销售的优先级。基于题目求的是利益最大化，那么我默认优先卖新鲜货然后卖滞销货，只有优先卖新鲜货才是利益最大的选择，一旦隔夜必定亏损。

我后面的文字已经跟原题关系不大了，回答了三个问题。1.货物是否一定会在某个时刻清空（实验）。2.120的进货量日均损失是否接近0（实验+猜测）。3.货物剩余震荡性增大的最重要原因是什么（实验+理论）。
作者: dynthia    时间: 2017-7-11 21:33
loy_20002000 发表于 2017-7-11 06:01
1.你的条理没有牛妖清晰。你给出Dp[t]=min(x[t],z[t]-y[t-1])-y[t-1]，我默认你赞成牛妖的处理方式。

1.1 ...

发现推导里面其实有一个问题，新增利润的表达式只对了一半，应该是：

Dp[t] = max(min(x[t],z[t]-y[t-1])-y[t-1], -z[t])

但如果还是做“大略”推导的话，不影响结论。
作者: dynthia    时间: 2017-7-11 21:46
本帖最后由 dynthia 于 2017-7-11 07:47 编辑
loy_20002000 发表于 2017-7-11 07:33
这只是一道简单的期望题而已，我只是提醒你用亏损的思路更加简洁。原回复的序号是混乱的，改了下明确了。 ...


如果先卖新货，那么

Dp[t] = z[t]   if x[t]>=z[t]
Dp[t] = x[t]-min(z[t]-x[t],y[t-1])   if x[t]<z[t]

这个时候120可能会合算，不过需要更多推导。
作者: dynthia    时间: 2017-7-11 21:56
loy_20002000 发表于 2017-7-11 07:33
这只是一道简单的期望题而已，我只是提醒你用亏损的思路更加简洁。原回复的序号是混乱的，改了下明确了。 ...


120的情况下货物是肯定会在某时刻清空的，因为对称的random walk在某个时刻到达边界的概率是1。振荡增大的原因是random walk引入的随机量的方差累积。
作者: loy_20002000    时间: 2017-7-11 22:09
dynthia 发表于 2017-7-11 21:56
120的情况下货物是肯定会在某时刻清空的，因为对称的random walk在某个时刻到达边界的概率是1。振荡增大 ...

这里之所以有如此长的讨论是由于题目的特殊性。如果发生130、140可以一直处理成---当日剩余=-10，-20，这是显然的。牛妖的分析是这道题会有【概率累积】的情况，即130、140发生前剩余=0，当多次发生后概率就会往100、110的方向累积，于是剩余会越来越大最终偏离0。
作者: dynthia    时间: 2017-7-11 22:15
本帖最后由 dynthia 于 2017-7-11 08:17 编辑
loy_20002000 发表于 2017-7-11 08:09
这里之所以有如此长的讨论是由于题目的特殊性。如果发生130、140可以一直处理成---当日剩余=-10，-20，这 ...


总体是偏离0，但从任何一个时刻算起在将来某个时刻（可以是非常遥远的某个时刻）达到0的概率是1，这不矛盾。
作者: loy_20002000    时间: 2017-7-12 20:43
本帖最后由 loy_20002000 于 2017-7-12 23:28 编辑
绿葱头 发表于 2017-7-4 13:53
对“需求没有得到满足也是亏损”这句不解，我刚写了程序用随机数模拟了下，被结果吓到了，如果按照前一天 ...

补充一个亏损计算法的过程吧。我认为是显然的，从其他人的回复看并非如此。原回复脑袋浆糊了，现在修改下。

前提1.不考虑保质期。

前提2.先卖新鲜货，后卖滞销货。新鲜货卖得越多利润越高，所以优先卖。单日利润只与新鲜货的销售量有关，与滞销货无关。

前提3.销售日期足够长。只有这样才能保证滞销货被清空。

1.进货100个。以下前面为销售量，后面为亏损量。注意：亏损与否只与新鲜面包滞销量与新鲜面包供给缺口有关！

100：0
110：-10
120：-20
130：-30
140：-40

日均亏损=-20。

2.进货110个

100：-10
110：0
120：-10
130：-20
140：--30

日均亏损=-14

3.进货120个

100：-20
110：-10
120：0
130：-10
140：-20

日均亏损=-12

4.进货130个

100：-30*4
110：-20*4
120：-10
130：0
140：-10

日均亏损=-44

5.进货140个

100：-40*4
110：-30*4
120：-20*4
130：-10*4
140:0

日均亏损=-80

显然120是亏损最小的选择。



作者: dynthia    时间: 2017-7-12 21:46
loy_20002000 发表于 2017-7-12 06:43
补充一个亏损计算法的过程吧。我认为是显然的，从其他人的回复看并非如此。

前提1.不考虑保质期。

进货100个为什么会有亏损？这里比较的是不同进货数字下的总体账面利润（负或正），如果把“机会成本”加进去会在某些地方导致重复计算的吧。
作者: loy_20002000    时间: 2017-7-12 22:11
dynthia 发表于 2017-7-12 21:46
进货100个为什么会有亏损？这里比较的是不同进货数字下的总体账面利润（负或正），如果把“机会成本”加 ...

嘿嘿，不会重复计算滴。我这个是一日一清，至于滞销货何时卖完则是另外一个问题。

亏损=新鲜面包剩余量 或者 新鲜面包供给缺口

先说供给剩余。当日新鲜面包剩余数量=亏损金额。之后卖掉已经跟利润没关系了，除非永远没法清空。

再说供给缺口。我卖100个面包，当日需求达到140的时候，可不是亏损40个新鲜面包的利润吗。因为本该到手的利润没有赚到。

这道题只有新鲜面包提供利润，面包一旦滞销必定亏损。所以盈利、亏损都是新鲜面包决定的。
作者: dynthia    时间: 2017-7-12 22:28
loy_20002000 发表于 2017-7-12 08:11
嘿嘿，不会重复计算滴。我这个是一日一清，至于滞销货何时卖完则是另外一个问题。

亏损=新鲜面包剩余量  ...

这不就是在算机会成本吗。照这么算，那进货120个比起100个还丧失了用多出来的80元进货费去做别的投资的利润呢。题目要求计算的显然是账面（正或负）利润啊。
作者: loy_20002000    时间: 2017-7-12 22:33
dynthia 发表于 2017-7-12 22:28
这不就是在算机会成本吗。照这么算，那进货120个比起100个还丧失了用多出来的80元进货费去做别的投资的利 ...

嘿嘿，题目要求的是利润最大化哦。亏损最小可不就是利润最大化吗。

我是回应你的重复计算问题呀。绝对没有啦。
作者: dynthia    时间: 2017-7-12 23:02
本帖最后由 dynthia 于 2017-7-12 09:04 编辑
loy_20002000 发表于 2017-7-12 08:33
嘿嘿，题目要求的是利润最大化哦。亏损最小可不就是利润最大化吗。

我是回应你的重复计算问题呀。绝对没 ...


我明白了，你是在计算相对于“完全能预知销售量从而调整进货量”的情况的相对亏损。在你的假设之下，这个计算对于100-120可能是成立的，因为滞销货带来的亏损总会在某个时刻被统计进去，但对于130和140，这个计算我觉得不成立，因为滞销货会累积而造成其销售收入永远不入账，也就是说其成本完全亏损掉了，不只是每个1元的亏损。
作者: 牛腰    时间: 2017-7-12 23:06
标题: ，
loy_20002000 发表于 2017-7-12 20:43
补充一个亏损计算法的过程吧。我认为是显然的，从其他人的回复看并非如此。

前提1.不考虑保质期。


这个算法有问题，没有考虑滞销面包的处理价格。假设每天滞销的面包处理给第3方，第二天只有新鲜面包出售。用最基本的利润定义：利润=收入-成本。

每个新鲜面包成本4元，出售价格5元。这两个数字不变。

如果滞销面包的处理价格是每个3元，那么收益表格就是

明显120个是最好的选择。

如果滞销面包的处理价格是每个2元，那么收益表格就是

最好的选择就变成110了。

按照你的算法似乎最好选择永远是120，和滞销面包处理价格无关。
作者: dynthia    时间: 2017-7-12 23:07
loy_20002000 发表于 2017-7-12 08:33
嘿嘿，题目要求的是利润最大化哦。亏损最小可不就是利润最大化吗。

我是回应你的重复计算问题呀。绝对没 ...

即使是其余的情况，这个“日均”也只在库存滞销量持平或减少的时间段有效，因为这时滞销货带来的亏损才是每个1元，而不是每个4元，至少对进货量120的情况，库存滞销量持平或减少的时间段并不能代表随机抽取的时间段。
作者: loy_20002000    时间: 2017-7-12 23:11
dynthia 发表于 2017-7-12 23:02
我明白了，你是在计算相对于“完全能预知销售量从而调整进货量”的情况的相对亏损。在你的假设之下，这个 ...

对的。后两项不该那么算。

这个问题我在前面的分析分析过，我自己居然忘记了。啊哈哈~~~
作者: dynthia    时间: 2017-7-12 23:14
牛腰 发表于 2017-7-12 09:06
这个算法有问题，没有考虑滞销面包的处理价格。假设每天滞销的面包处理给第3方，第二天只有新鲜面包出售 ...

他的算法是认为滞销货“总有一天”会被以3元卖出去，从而相对于“完美销售”带来1元亏损，这个是考虑了滞销货处理价格的。
作者: dynthia    时间: 2017-7-12 23:15
loy_20002000 发表于 2017-7-12 09:11
对的。后两项不该那么算。

这个问题我在前面的分析分析过，我自己居然忘记了。啊哈哈~~~ ...

是的，但是看我上面的分析，对120的情况，这个“日均”也不是典型的“日均”。
作者: loy_20002000    时间: 2017-7-12 23:22
牛腰 发表于 2017-7-12 23:06
这个算法有问题，没有考虑滞销面包的处理价格。假设每天滞销的面包处理给第3方，第二天只有新鲜面包出售 ...

肯定按原题意是最好的啦。你的分析题意都变了。

我最后的两项是错误的。晕，阴沟里翻船。
作者: 牛腰    时间: 2017-7-12 23:22
dynthia 发表于 2017-7-12 23:14
他的算法是认为滞销货“总有一天”会被以3元卖出去，从而相对于“完美销售”带来1元亏损，这个是考虑了滞 ...

明白了，他的baseline是假设每天的进货都是那一天的实际销售量，既没有滞销，也没有lost sales
作者: dynthia    时间: 2017-7-12 23:30
牛腰 发表于 2017-7-12 09:22
明白了，他的baseline是假设每天的进货都是那一天的实际销售量，既没有滞销，也没有lost sales ...

是的，但是这个“总有一天会卖出去”的假设隐含了对采样点的要求，所以计算结果至少对120应该是高估了。
作者: 牛腰    时间: 2017-7-12 23:37
loy_20002000 发表于 2017-7-12 23:22
肯定按原题意是最好的啦。你的分析题意都变了。

我最后的两项是错误的。晕，阴沟里翻船。 ...

确实没看懂130/140的分析，以为你假设不论进货多少滞销面包都能处理完，既有个无限容量的第三方。
作者: dynthia    时间: 2017-7-12 23:43
牛腰 发表于 2017-7-12 09:37
确实没看懂130/140的分析，以为你假设不论进货多少滞销面包都能处理完，既有个无限容量的第三方。 ...

他的算法实际上确实相当于滞销货全部可以按3元价格立刻销售出去，不影响第二天销售量，也即最简化的题意。
作者: loy_20002000    时间: 2017-7-12 23:44
牛腰 发表于 2017-7-12 23:22
明白了，他的baseline是假设每天的进货都是那一天的实际销售量，既没有滞销，也没有lost sales ...

你说的降价2元按照我的算法再来一遍。阴沟里翻船，没法原谅自己呀。

前面为销量，后面是亏损

1.进货100

100：0
110：-10
120：-20
130：-30
140：-40

日均亏损=-20

2.进货110

100：-20
110：0
120：-10
130：-20
140：-30

日均亏损=-16

3.进货120

100：-40
110：-20
120：0
130：-10
140：-20

日均亏损=-18

4.进货130

100：-30*4
110：-20*4
120：-20
130：0
140：-10

日均亏损=-46

5.进货140

100：-40*4
110：-30*4
120：-20*4
130：-10*4
140：0

日均亏损=-80

由上，110在降价2元的情况下是最优解。我的算法没问题。
作者: dynthia    时间: 2017-7-12 23:46
loy_20002000 发表于 2017-7-12 09:44
你说的降价2元按照我的算法再来一遍。阴沟里翻船，没法原谅自己呀。

前面为销量，后面是亏损

上面说了，你对110和120计算出的日均未必就是典型的“日均”，特别是120的情况。
作者: loy_20002000    时间: 2017-7-12 23:46
牛腰 发表于 2017-7-12 23:37
确实没看懂130/140的分析，以为你假设不论进货多少滞销面包都能处理完，既有个无限容量的第三方。 ...

那个是我弄错了，请直接忽略。我的错误太低级了，这真是没法说。
作者: loy_20002000    时间: 2017-7-12 23:51
dynthia 发表于 2017-7-12 23:07
即使是其余的情况，这个“日均”也只在库存滞销量持平或减少的时间段有效，因为这时滞销货带来的亏损才是 ...

所以我说不考虑保质期呀。之前给楼主的回复给出过一个解决保质期问题的方案，至于有多少可行性就不好说了。
作者: dynthia    时间: 2017-7-12 23:53
本帖最后由 dynthia 于 2017-7-12 09:54 编辑
loy_20002000 发表于 2017-7-12 09:51
所以我说不考虑保质期呀。之前给楼主的回复给出过一个解决保质期问题的方案，至于有多少可行性就不好说了 ...


是不考虑，但是，你的“日均”只有在库存滞销量持平或减少的时间段才是“日均”，如果采样时间段是其它的时间段，就不会得到这个“日均”。也就是说，至少对120，你只考虑了亏损比较小的时间段，而没有考虑亏损比较大的时间段，这样造成总体亏损估计偏低。
作者: loy_20002000    时间: 2017-7-12 23:55
dynthia 发表于 2017-7-12 23:46
上面说了，你对110和120计算出的日均未必就是典型的“日均”，特别是120的情况。 ...

如果你指的是保质期的问题，引入这个条件问题就太复杂了。不考虑的话，100、110、120的库存总有一天能清空，算当日利润就行了。130、140的处理是大于消化能力的量统统报废处理，即每个面包亏损4元，所以还是能这么处理。
作者: loy_20002000    时间: 2017-7-12 23:56
dynthia 发表于 2017-7-12 23:53
是不考虑，但是，你的“日均”只有在库存滞销量持平或减少的时间段才是“日均”，如果采样时间段是其它的 ...

你具体化一些，例如给俩例子，我不明白你的意思。
作者: dynthia    时间: 2017-7-12 23:57
loy_20002000 发表于 2017-7-12 09:55
如果你指的是保质期的问题，引入这个条件问题就太复杂了。不考虑的话，100、110、120的库存总有一天能清 ...

你的计算只对100有效，因为其库存永远是0。即使对110，也总会有库存上涨的时间段，所以其总体平均亏损也被低估了，但没有120那么严重。
作者: loy_20002000    时间: 2017-7-13 00:00
dynthia 发表于 2017-7-12 23:57
你的计算只对100有效，因为其库存永远是0。即使对110，也总会有库存上涨的时间段，所以其总体平均亏损也 ...

如果不考虑保质期，昨天的库存积压关今天的亏损什么事情呢？
作者: dynthia    时间: 2017-7-13 00:04
loy_20002000 发表于 2017-7-12 09:56
你具体化一些，例如给俩例子，我不明白你的意思。

假如你选取一个时间段，起始库存是A，结束库存是B。

当B<=A时，这个时间段内所有新进的面包都销售出去了，相对于“完美销售”，你的日均算法基本是正确的（这里还有一个时间平均是否等于按日期望的问题，如果采样点能保证B=A，我觉得差不多可以假定这个按日期望和时间段内的时间平均是一样的，如果B<A还比较难说，所以这里只说“基本”）。

当B>A时，新进的面包至少有一部分相对于“完美销售”造成的亏损是4而不是1，也就是说日均算法低估了这个时间段内的总体相对亏损。

在进货120的情况下，随机选取两个时间点，得到B>A的可能性是不可忽略的，所以，你的算法对这个随机选取的时间段内的总体相对亏损实际是偏低的。
作者: loy_20002000    时间: 2017-7-13 00:11
dynthia 发表于 2017-7-13 00:04
假如你选取一个时间段，起始库存是A，结束库存是B。

当BA的可能性是不可忽略的，所以，你的算法对这个随 ...
当B>A时，新进的面包至少有一部分相对于“完美销售”造成的亏损是4而不是1


这是为什么，还是不懂。
作者: dynthia    时间: 2017-7-13 00:18
本帖最后由 dynthia 于 2017-7-12 10:25 编辑
loy_20002000 发表于 2017-7-12 10:11
这是为什么，还是不懂。


你的假设是“每一天的进货量导致在将来某个时刻会最终产生的总体亏损期望”就是“长期来看日均亏损的期望值”，但这个未必是成立的，因为“将来某个时刻”可以非常非常遥远，远到不管你怎么选“长期”，里面总有一些进货量产生的收入不能计算到这个“长期”的总亏损之中，也就拉高了这个“长期”的日均亏损。

如果“将来某个时刻”是很短的，比如总是在第二天全部销售给了第三方，那么这个假设可以成立，但那样就等于是简化版的题了。



欢迎光临 爱吱声 (http://129.226.69.186/bbs/) Powered by Discuz! X3.2