精华内容
下载资源
问答
  • 如果 public void test2Trans() { long start = System.currentTimeMillis(); Transaction tx = jedis.multi(); try{ for (int i = 0; i ; i++) { tx.set("t" + i, "t" + i);... System.out.println(...
  • 排队

    千次阅读 2018-08-29 22:44:49
    排队论(Queuing Theory)也称 随机服务系统理论,就是为解决上述问题而发展的一门学科。 它研究的内容有下列三部分: (i)性态问题,即研究各种排队系统的概率规律性,主要是研究队长分布、等待时间分布和忙期...

    排队论(Queuing Theory)也称 随机服务系统理论,就是为解决上述问题而发展的一门学科。

    它研究的内容有下列三部分:
    (i)性态问题,即研究各种排队系统的概率规律性,主要是研究队长分布、等待时间分布和忙期分布等,包括了瞬态和稳态两种情形
    (ii)最优化问题,又分静态最优和动态最优,前者指最优设计。后者指现有排队系统的最优运营
    (iii)排队系统的统计推断,即判断一个给定的排队系统符合于哪种模型,以便根据排队理论进行分析研究。

    一、基本概念

    1。排队论的一般模型

    图中虚线所包含的部分为排队系统。各个顾客从顾客源出发,随机地来到服务机构,按一定的排队规则等待服务,直到按一定的服务规则接受完服务后离开排队系统。

    凡要求服务的对象统称为 顾客,为顾客服务的人或物称为 服务员,由顾客和服务员组成服务系统。对于一个服务系统来说,如果服务机构过小,以致不能满足要求服务的众多顾客的需要,那么就会产生拥挤现象而使服务质量降低。 因此,顾客总希望服务
    机构越大越好,但是,如果服务机构过大,人力和物力方面的开支也就相应增加,从而会造成浪费,因此研究排队模型的目的就是要在顾客需要和服务机构的规模之间进行权衡决策,使其达到合理的平衡。

    2.排队系统的组成和特征:输入过程、排队规则、服务过程三部分

    1)输入过程

    (i)顾客的组成可能是有限的,也可能是无限的。

    (ii)顾客到达的方式可能是一个—个的,也可能是成批的。

    (iii)顾客到达可以是相互独立的,即以前的到达情况对以后的到达没有影响;否则是相关的。

    (iv)输入过程可以是平稳的,即相继到达的间隔时间分布及其数学期望、方差等数字特征都与时间无关,否则是非平稳的。

    2)排队规则:损失制,等待制和混合制三种。

    排队方式还分为单列、多列和循环队列。

    (i)损失制(消失制)。当顾客到达时,所有的服务台均被占用,顾客随即离去
    (ii)等待制。当顾客到达时,所有的服务台均被占用,顾客就排队等待,直到接受完服务才离去。例如出故障的机器排队等待维修就是这种情况。
    (iii)混合制。介于损失制和等待制之间的是混合制,即既有等待又有损失。有队列长度有限和排队等待时间有限两种情况,在限度以内就排队等待,超过一定限度就离去。

    3)服务过程

    (i)服务机构。主要有以下几种类型:单服务台多服务台并联(每个服务台同时不同顾客服务);多服务台串联(多服务台依次同一顾客服务);混合型。
    (ii)服务规则。按为顾客服务的次序采用以下几种规则:
    先到先服务,这是通常的情形。
    后到先服务,如情报系统中,最后到的情报信息往往最有价值,因而常被优先处理。
    随机服务,服务台从等待的顾客中随机地取其一进行服务,而不管到达的先后。
    优先服务,如医疗系统对病情严重的病人给予优先治疗。

    4.排队模型的符号表示

    排队模型用六个符号表示,在符号之间用斜线隔开,即 X/Y/Z/A/B/C。

    X:表示顾客到达流顾客到达间隔时间的分布

    Y:表示服务时间的分布

    Z:服务台数目

     A 是系统容量限制

     B 是顾客源数目

     C 是服务规则,eg:先到先服务 FCFS,后到先服务 LCFS 等

    注意:并约定,如略去后三项,即指 X/ Y/Z/ ∞/∞ / FCFS 的情形。我们只讨论先到先服务 FCFS的情形,所以略去第六项。

    表示顾客到达间隔时间服务时间的分布的约定符号为:
    M —指数分布( M 是 Markov 的字头,因为指数分布具有无记忆性,即 Markov性);
    D —确定型(Deterministic);
    E_{_{k}}— k 阶爱尔朗(Erlang)分布;
    G —一般(general)服务时间的分布;
    GI —一般相互独立(General Independent)的时间间隔的分布。

    具体例子:

    M/M/1 表示顾客相继到达间隔时间为指数分布、服务时间为指数分布、单服台、等待制系统。

     D/M/C表示确定的到达时间、服务时间为指数分布、 c 个平行服务台(但顾客是一队)的模型。

    5.排队系统的运行指标

    为了研究排队系统运行的效率估计其服务质量确定系统的最优参数评价系统的结构是否合理并研究其改进的措施,必须确定用以判断系统运行优劣的基本数量指标,这些数量指标通常是:

    (i) 平均队长:指系统内顾客数(包括正被服务的顾客与排队等待服务的顾客)的数学期望,记作L_{s}

    (ii) 平均排队长:指系统内等待服务的顾客数的数学期望,记作L_{q}

    (iii) 平均逗留时间:顾客在系统内逗留时间(包括排队等待的时间和接受服务的时间)的数学期望,记作W_{s}

    (iv) 平均等待时间:指一个顾客在排队系统中排队等待时间的数学期望,记作W_{q}

    (v) 平均忙期:指服务机构连续繁忙时间(顾客到达空闲服务机构起,到服务机构再次空闲止的时间)长度的数学期望,记为T_{b}

    还有由于顾客被拒绝而使企业受到损失的 损失率以及以后经常遇到的服务强度等,这些都是很重要的指标

    计算这些指标的基础是表达系统状态的概率。所谓 系统的状态即指系统中顾客数,
    如果系统中有 n 个顾客就说系统的状态是 n ,它的可能值是
    (i)队长没有限制时,n= 0,1,2。。
    (ii)队长有限制,最大数为 N 时,n=0,1,2,。。。N 
    (iii)损失制,服务台个数是 c 时,n=0,1,。。。。c 

    这些状态的概率一般是随时刻 t 而变化,所以在时刻 t 、系统状态为 n 的概率{{\rm{P}}_{\rm{n}}}(t)表示。稳态时系统状态为 n 的概率用P_{n}表示。

    二、输入过程与服务时间的分布

    排队系统中的事件流包括顾客到达流和服务时间流。由于顾客到达的间隔时间和服务时间不可能是负值,因此,它的分布是非负随机变量的分布。最常用的分布有泊松分布、确定型分布,指数分布和爱尔朗分布

    1)泊松流与指数分布

    输入过程:

    当输入过程是泊松流时,那么顾客相继到达的时间间隔 T 必服从指数分布。

    对于泊松流, λ 表示单位时间平均到达的顾客数
    1/ λ 表示相继顾客到达平均间隔时间

    服务过程:

    对一顾客的服务时间也就是在忙期相继离开系统的两顾客的间隔时间,有时也服从指数分布。

    这时设它的分布函数和密度函数分别是

     μ 表示单位时间能被服务完成的顾客数,称为平均服务率
    1/μ表示一个顾客的平均服务时间

    2)常用的连续型概率分布

    (i)均匀分布

    (ii)正态分布

    (iii)指数分布:指数分布是唯一具有无记忆性的连续型随机变量

    (iv)Gamma 分布:又称爱尔朗分布。Gamma 分布可用于服务时间,零件寿命等。

    (v)Weibull 分布:作为设备、零件的寿命分布在可靠性分析中有着非常广泛的应用。

    (vi)Beta 分布

    3)常用的离散型概率分布

    (i)离散均匀分布

    (ii)Bernoulli 分布(两点分布),用于基本的离散模型

    (iii)泊松(Poisson)分布:泊松分布与指数分布有密切的关系。当顾客平均到达率为常数 λ 的到达间隔服从指数分布时,单位时间内到达的顾客数 K 服从泊松分布,即单位时间内到达 k 位顾客的概率为

    记作 ( Poisson λ )。泊松分布在排队服务、产品检验、生物与医学统计、天文、物理等领域都有广泛应用。

    (iv)二项分布

    三、生灭过程

    在排队论中,如果N (t)表示时刻 t 系统中的顾客数,则 {N(t),t>=0} 就构成了一个随机过程,就是一类特殊的随机过程-生灭过程(生”表示顾客的到达,“灭”表示顾客的离去)。

    为求平稳分布,考虑系统可能处的任一状态 n 。假设记录了一段时间内系统进入状态 n 和离开状态 n 的次数,则因为“进入”和“离开”是交替发生的,所以这两个数要么相等,要么相差为 1。但就这两种事件的平均发生率来说,可以认为是相等的。即当系统运行相当时间而到达平衡状态后,对任一状态 n 来说,单位时间内进入该状态的平均次数和单位时间内离开该状态的平均次数应该相等,这就是系统在统计平衡下的“流入=流出”原理

    如何求平稳分布?

    假设已经得到了平稳状态分布,如下所示

    更重要的是:

    才能由上述公式得到平稳状态的概率分布
     

    四、M/M/s等待制排队模型

    1)单服务台模型M /M/1/∞ (因为服务台只有一个,要立马进行排队,注意求和的上下标)

    单服务台等待制模型 M /M/1/∞ 是指:顾客的相继到达时间服从参数为 λ 的负指数分布,服务台个数为 1,服务时间 V 服从参数为 μ 的负指数分布,系统空间无限,允许无限排队,这是一类最简单的排队系统。

     

    需要掌握的有:队长的分布,平均队长、平均排队长以及平均队长与平均逗留时间的关系平均排队长与平均等待时间的关系(Little公式

    要知道:顾客在系统中的逗留时间等待时间T_{q}接受服务时间V 之和,具体的推倒过程,我直接放图了

    具体的一个eg:

     

    2)多服务台模型M/M/S/∞(因为服务台有s个,所以当n>=s个的时候,才需要排队,注意求和的上下标)

    顾客单个到达相继到达时间间隔服从参数为λ 的负指数分布,系统中共有 s 个服务台每个服务台的服务时间相互独立且服从参数为 μ 的负指数分布。当顾客到达时, 若有空闲的服务台则马上接受服务, 否则便排成一个队列等待, 等待时间为无限。

     

    3)M / M / s / s 损失制排队模型

    当 s 个服务台被占用后,顾客自动离去。

    4)M / M / s 混合制排队模型

    i)单服务台混合制模型
    单服务台混合制模型 M / M /1/ K 是指:顾客的相继到达时间服从参数为λ 的负指数分布,服务台个数为1,服务时间V 服从参数为 μ 的负指数分布,系统的空间为 K ,当 K个位置已被顾客占用时,新到的顾客自动离去,当系统中有空位置时,新到的顾客进入系统排队等待

    eg:一看就懂的例子

    多服务台混合制模型(重点关注一下)
    多服务台混合制模型 M / M / s / K 是指顾客的相继到达时间服从参数为 λ 的负指数分布,服务台个数为 s ,每个服务台服务时间相互独立,且服从参数为 μ 的负指数分布,系统的空间为 K 。
     

    其它排队模型

    1)有限源排队模型

    2)服务率或到达率依赖状态的排队模型

    在前面的各类排队模型的分析中,均假设顾客的到达率为常数 λ ,服务台的服务率也为常数 μ 。而在实际的排队问题中,到达率或服务率可能是随系统的状态而变化的。例如,当系统中顾客数已经比较多时,后来的顾客可能不愿意再进入系统;服务员
    的服务率当顾客较多时也可能会提高。
     

     

    展开全文
  • NGUI WrapContent显示多行多列

    千次阅读 2016-11-07 14:54:02
    在游戏中我们时常看到像背包一样用ScrollView来拖动展示一些物品信息,物品一那么开始克隆的Item就会这样使得开始打开界面时耗时长,而且在滑动的时候会出现卡顿,滑动不流畅,滑动卡顿的主要原因是我们未将移出...

    在游戏中我们时常看到像背包一样用ScrollView来拖动展示一些物品信息,物品一多那么开始克隆的Item就会多这样使得开始打开界面时耗时长,而且在滑动的时候会出现卡顿,滑动不流畅,滑动卡顿的主要原因是我们未将移出UIScrollView的Item设为false,这会导致Panel在重建DrawCall是将所有的Item都算进来,这时在构建Mesh时会很耗时特别是Item比较多的时候,针对这两个问题我们可以用少量的Item循环使用来解决;NGUI本身就给我们提供了这个代码:UIWrapContent,具体用法NGUI有事例,但它们都是单行单列的,这里我简单的说下怎么用UIWrapContent来展示多行多列的。

    先来看看效果:

    这里循环使用15个Item来显示0~31,拉到底时不能再往下或往上拉。

    Ok,进入主题,下面来说说我的做法,先来看看下面代码:

    using UnityEngine;
    
    public class MultiRowWrapContent : UIWrapContent
    {
        public int RowNum = 3;
    
        protected override void ResetChildPositions()
        {
            for (int i = 0, imax = mChildren.Count; i < imax; ++i)
            {
                Transform t = mChildren[i];
                t.localPosition = mHorizontal ? new Vector3(i * itemSize, 0f, 0f) : new Vector3((i % RowNum) * itemSize, -(i / RowNum) * itemSize, 0f);
                UpdateItem(t, i);
            }
        }
    
        protected override void UpdateItem(Transform item, int index)
        {
            if (onInitializeItem != null)
            {
                int yIndex = Mathf.Abs(Mathf.RoundToInt(item.localPosition.y / itemSize));
                int xIndex = Mathf.Abs(Mathf.RoundToInt(item.localPosition.x / itemSize));
                int realIndex = RowNum * yIndex + xIndex;
                onInitializeItem(item.gameObject, index, realIndex);
            }
        }
        //重写这个函数主要是去掉排序
        //if (mHorizontal) mChildren.Sort(UIGrid.SortHorizontal);
    	//	else mChildren.Sort(UIGrid.SortVertical);
        public override void SortBasedOnScrollMovement()
        {
            if (!CacheScrollView()) return;
    
            // Cache all children and place them in order
            mChildren.Clear();
            for (int i = 0; i < mTrans.childCount; ++i)
            {
                Transform t = mTrans.GetChild(i);
                if (hideInactive && !t.gameObject.activeInHierarchy) continue;
                mChildren.Add(t);
            }
    
            ResetChildPositions();
        }
    
        public override void WrapContent()
        {
            float extents = itemSize * (mChildren.Count / RowNum) * 0.5f;
            Vector3[] corners = mPanel.worldCorners;
    
            for (int i = 0; i < 4; ++i)
            {
                Vector3 v = corners[i];
                v = mTrans.InverseTransformPoint(v);
                corners[i] = v;
            }
    
            Vector3 center = Vector3.Lerp(corners[0], corners[2], 0.5f);
            bool allWithinRange = true;
            float ext2 = extents * 2f;
    
            if (mHorizontal)
            {
                float min = corners[0].x - itemSize;
                float max = corners[2].x + itemSize;
    
                for (int i = 0, imax = mChildren.Count; i < imax; ++i)
                {
                    Transform t = mChildren[i];
                    float distance = t.localPosition.x - center.x;
    
                    if (distance < -extents)
                    {
                        Vector3 pos = t.localPosition;
                        pos.x += ext2;
                        distance = pos.x - center.x;
                        int realIndex = Mathf.RoundToInt(pos.x / itemSize);
    
                        if (minIndex == maxIndex || (minIndex <= realIndex && realIndex <= maxIndex))
                        {
                            t.localPosition = pos;
                            UpdateItem(t, i);
                        }
                        else allWithinRange = false;
                    }
                    else if (distance > extents)
                    {
                        Vector3 pos = t.localPosition;
                        pos.x -= ext2;
                        distance = pos.x - center.x;
                        int realIndex = Mathf.RoundToInt(pos.x / itemSize);
    
                        if (minIndex == maxIndex || (minIndex <= realIndex && realIndex <= maxIndex))
                        {
                            t.localPosition = pos;
                            UpdateItem(t, i);
                        }
                        else allWithinRange = false;
                    }
                    else if (mFirstTime) UpdateItem(t, i);
    
                    if (cullContent)
                    {
                        distance += mPanel.clipOffset.x - mTrans.localPosition.x;
                        if (!UICamera.IsPressed(t.gameObject))
                            NGUITools.SetActive(t.gameObject, (distance > min && distance < max), false);
                    }
                }
            }
            else
            {
                float min = corners[0].y - itemSize;
                float max = corners[2].y + itemSize;
    
                for (int i = 0, imax = mChildren.Count; i < imax; ++i)
                {
                    Transform t = mChildren[i];
                    float distance = t.localPosition.y - center.y;
    
                    if (distance < -extents)
                    {
                        Vector3 pos = t.localPosition;
                        pos.y += ext2;
                        distance = pos.y - center.y;
                        int realIndex = Mathf.RoundToInt(pos.y / itemSize);
    
                        if (minIndex == maxIndex || (minIndex <= realIndex && realIndex <= maxIndex))
                        {
                            t.localPosition = pos;
                            UpdateItem(t, i);
                        }
                        else allWithinRange = false;
                    }
                    else if (distance > extents)
                    {
                        Vector3 pos = t.localPosition;
                        pos.y -= ext2;
                        distance = pos.y - center.y;
                        int realIndex = Mathf.RoundToInt(pos.y / itemSize);
    
                        if (minIndex == maxIndex || (minIndex <= realIndex && realIndex <= maxIndex))
                        {
                            t.localPosition = pos;
                            UpdateItem(t, i);
                        }
                        else allWithinRange = false;
                    }
                    else if (mFirstTime) UpdateItem(t, i);
    
                    if (cullContent)
                    {
                        distance += mPanel.clipOffset.y - mTrans.localPosition.y;
                        if (!UICamera.IsPressed(t.gameObject))
                            NGUITools.SetActive(t.gameObject, (distance > min && distance < max), false);
                    }
                }
            }
            mScroll.restrictWithinPanel = !allWithinRange;
            mScroll.InvalidateBounds();
        }
    }
    
    上面的代码是继承了UIWrapContent并对里面的几个函数进行重写的,主要的改动有:

    1、各个Item的位置设置:t.localPosition = mHorizontal ? new Vector3(i * itemSize, 0f, 0f) : new Vector3((i % RowNum) * itemSize, -(i / RowNum) * itemSize, 0f);这里我只做了垂直方向的,(i%RowNum)*itemSize横向坐标,-(i/RowNum)*itemSize纵向坐标;

    2、改变了 UpdateItem中realIndex的计算这个是要显示的数据角标:先算出要改变的item在的行号和列号,它要显示的数据的角标=行号*列数+列号;

    3、WrapContent()里的float extents = itemSize * mChildren.Count / RowNum * 0.5f;这个是计算所有Item按照每行RowNum个排列纵向长度的一半;
    主要就是这三个地方的改动,还有就是我在后显示做了处理,就是最后一行不满RowNum个时,将没有数据可替换的隐藏,当有时显示。代码如下:

    void OnInitializeItem(GameObject go, int wrapIndex, int realIndex)
        {
            
            go.name = Mathf.Abs(realIndex).ToString();
            UILabel label = go.transform.FindChild("Label").GetComponent<UILabel>();
            int index = Mathf.Abs(realIndex);
            if (index < nums.Count)
            {
                go.SetActive(true);
                label.text = nums[index].ToString();
            }
            else
            {
                go.SetActive(false);
            }
        }
    Ok,到此基本已经好了,这样就实现了多行多列的显示了。


    展开全文
  • 根据dataframe某列或多列进行拆分,获得小dataframe后从大到小排序,取前90%,再合并成一个大的dataframe

    日拱一卒,功不唐捐

    知识点

    1. exec()
    2. enumerate()
    3. isin()
    4. concat()

    新创建DataFrame

    import datetime
    import pandas as pd
    import numpy as np
    
    #定义list拓展函数
    def list_extend(_list,times):
        OrginList=[_list for _i in range(times)]
        
        _extendList=[]
        
        for k,j in enumerate(OrginList):
            for i in j:
                _extendList.append(i)
            
        return _extendList
    
    # 定义日期循环函数
    def Date(start,end):
        _date=[]
        for i in range((end-start).days+1):
            _date.append(start + datetime.timedelta(days=i))
        return _date
    
    #创建DataFrame
    ShopName=["Sam's Club",'bravo','WU MART','Vangguard']
    start=datetime.date(2019,1,1)
    end=datetime.date(2019,6,1)
    
    data = pd.DataFrame({'ShopName':list_extend(ShopName,38),
                          'income':random.sample(list(range(0,200)),152),
                          'date':Date(start,end)})
    data.head(3)
    

    在这里插入图片描述


    1. 根据某列值拆分成多个表

    对商品进行分组,获取小dataframe

    for shop_index,temp_shop_info in enumerate(shop_info):
        #对ShopName商铺进行拆分
        temp_shop_data=data[data['ShopName'].isin([temp_shop_info])]
        exec("df%s=temp_shop_data"%shop_index)
        
    df1.head(4)
    

    在这里插入图片描述


    2. 根据多列值拆分成多个表

    先对商品进行分组,再对月份进行分组,获取小dataframe

    for shop_index,temp_shop_info in enumerate(shop_info):
        #对ShopName商铺进行拆分
        temp_shop_data=data[data['ShopName'].isin([temp_shop_info])]
        for month_index,temp_month_info in enumerate(month_info):
            #对month进行拆分
            temp_month_date=temp_shop_data[temp_shop_data['month'].isin([temp_month_info])]
            exec("df%s=temp_month_date"%month_index)
    
    df0
    

    在这里插入图片描述


    3. 多个DataFrame合并成一个大的DataFrame

    先对商品进行分组,再对月份进行分组,获取小dataframe,对income值从大到小排序,取前90%数据后获得新的dataframe,再把所有小dataframe合并成一个大的dataframe

    df_frames=[]
    for shop_index,temp_shop_info in enumerate(shop_info):
        #对ShopName商铺进行拆分
        temp_shop_data=data[data['ShopName'].isin([temp_shop_info])]
        for month_index,temp_month_info in enumerate(month_info):
            #对month进行拆分
            temp_month_date=temp_shop_data[temp_shop_data['month'].isin([temp_month_info])]
            #从大到小排队,取前90%
            temp_date=temp_month_date[0:int(len(temp_month_date)*0.9)]
            df_frames.append(temp_date)
        
    result=pd.concat(df_frames)
    result  
    
    展开全文
  • 排队论在食堂排队中的运用

    千次阅读 2019-05-29 16:39:06
    排队在日常生活中是非常常见的现象。在学校中,每次到了饭点的时间,食堂都会水泄不通,对于同学们来说,减少排队等待时间是同学们的需求,但是对于食堂来说,增加窗口的同时,也会相应增加运营成本,如何设置窗口的...

    一、问题描述
    排队在日常生活中是非常常见的现象。在学校中,每次到了饭点的时间,食堂都会水泄不通,对于同学们来说,减少排队等待时间是同学们的需求,但是对于食堂来说,增加窗口的同时,也会相应增加运营成本,如何设置窗口的数量,达到双方都能接受并相对满意的程度是值得分析的。

    理论准备
    

    1、排队系统的符号一般形式为:X/Y/Z/A/B/C。
    其中:X 表示顾客相继到达时问间隔的分布;Y 表示服务时间的分布;Z 表示服务台的个数;A 表示系统的容量,即可容纳的最多顾客数;B 表示顾客源的数目;C 表示服务规则。

    2、排队结构与排队规则
    顾客排队方式:等待制/损失制
    

    排队系统容量:有限制/无限制
    排队队列数目:单列/多列
    是否中途退出:允许/禁止
    是否列间转移:允许/禁止

    3、服务机构与服务规则
    服务员数目:单个/多个
    服务员排列形式:并列/串列/混合
    服务时间分布是否平稳:平稳/非平稳

    4、排队论(Queuing Theory) ,是研究系统随机聚散现象和随机服务系统工作过程的数学理论和方法,又称随机服务系统理论,为运筹学的一个分支。从排队系统进程的主要因素来看,它主要由三部分组成:输入输出、排队规则和服务规则,此食堂窗口服务系统研究模型假设为 M/M/s 等待制多服务台模型。
    涉及的主要指标:
    平均排队长度L_q=(P_0 ρ^s ρ_s)/(s!(1-ρ_s )^2 ):系统中排队等待服务的顾客数
    平均等待时间W_q=L_q/λ:一个顾客在系统中的排队时间
    平均逗留时间W_s=W+t ̅:一个顾客在系统的全部停留时间
    平均顾客数L_s=L_q+ρ;
    平均到达率λ;
    平均服务率μ;
    并联服务台的数目S;
    服务台强度 , 即每个服务台单位时间间隔内的平均服务时间ρ=λ/μs;
    系统的稳态概率P_0=[(∑_(i=0)n▒ρi/i!)+ρ^(n+1)/n!(n-ρ) ]^(-1)和繁忙概率P。

    三、实例分析

    1、模型假设
    1.1假定学生在高峰期这段时间达到的人数是无限的,并且是符合参数为λ的泊松分布的,因学生达到的时间间隔是随机的,服从负指数分布。
    1.2每个服务窗口以并联的方式连接,每个窗口服务上无差别,服务时间服从参数为μ的负指数分布
    1.3窗口实行先来先服务原则,认为学生固定在一条队列里排队,不可移动到别的队列中去。
    统计了从某周一到周五11:35 至12:15 午饭高峰期食堂的学生流分布情况:共统计了2615人次的数据(以10 秒为一个时间单位),如下:
    每10秒到达人数 1 2 3 4 5 6
    频数 220 375 765 815 300 140
    由概率论的知识可知,若分布满足P_k/P_(k-1) =λ/K,则该分布为泊松分布。(其中P_k为泊松分布的密度,λ为泊松分布的参数)
    λ=1220/2615+2375/2615+3765/2615+4815/2615+5300/2615+6140/2615=3.38
    由上表可得λ =3.38。经检验,该分布近似于泊松分布。虽然只收集了一周的数据,但考虑到学生到食堂就餐具有较大的稳定性,所以认为收集的数据还是较为可靠的。另不在非高峰期采集数据。

    2、模型建立及求解
    基于以上的假设,我们的模型符合排队论中的多服务台等待模型(M/M/S)。该模型的特点是:服务系统中有S个窗口,学生按泊松分布来到服务系统,到达强度为λ;服务员的能力都是µ,服务时间服从指数分布,每个学生的平均服务时间t ̅。当学生到达时,如果所有排队队伍都有人了,学生可以选择一个窗口进行排队,等待服务。
    到达强度λ=3.38,每位学生的服务时间t ̅=1.3,食堂目前窗口数量s=5;
    服务员能力:μ=1/t ̅ =0.76
    系统服务强度:ρ=λ/μ=4.45,ρ_s=ρ/s=4.45/5=0.889<1
    空闲概率:p_0=[(∑_(i=0)n▒ρi/i!)+ρ^(n+1)/n!(n-ρ) ](-1)=[1+4.45+(0.889)2/5!(1-0.889) ]^(-1)=0.181
    系统中排学生的平均数:L_q=(P_0 ρ^s ρ_s)/(s!(1-ρ_s )^2 )=189.91
    学生平均排队时间:W=L_q/λ=57.48
    学生平均逗留时间:W_q=W+t ̅=57.48+1.3=58.78
    系统中学生的平均数:L=L_q+ρ=189+4.45=193.45

    在11:35——12:15这段时间内,系统中有189个同学正在排队买饭,193个同学正在排队等待,平均一个窗口38人。当我们开始排队时,要排574秒才被轮到,要等587秒才可以吃上饭。

    3、模型分析
    学生在食堂排队的平均逗留时间W_q很大程度上会影响学生对食堂的选择。研究学生平均逗留时间W_q,是解决此问题的关键点。
    平均逗留时间W_q是由平均排队时间W和平均服务时间t ̅组成。我们认为13秒的平均服务时t ̅对于服务员来说已经是最快的服务时间了,服务时间无弹性,故认为平均服务时间t ̅是个常量。
    至于平均排队时W,我们由公式可知它是由顾客到达强度λ,每个顾客的平均服务时t ̅和窗口数S来决定的,由于学生对于食堂的选择比较固定,即一般都会去同一个食堂吃饭,所以我们可以认为学生流是稳定的,即λ为常数,由上面的分析又可t ̅也是常数,因此只有窗口数会影响等待排队时间了,下面我们就S的取值对W的影响进行分析:
    由Excel可以得到它们两者之间的拟合分析图:

    纵坐标代表平均等待时间W(10秒)
    横坐标代表S的窗口数
    从图中可以看出,随着窗口数的增加,平均排队等待时间急剧减少,当窗口数为7时,等待时间已经下降超过窗口数为5时的一半以上,随着窗口数的持续增加,等待时间不断减少,但是减少的变化量逐渐下降

    4、灵敏度分析

    窗口数S 5 6 7 8 9 10 11
    平均排队时间W(10秒为单位) 0 42.9 27.79 16.0 8.5 4.5 2.6
    ∆W 14.5 15.2 11.7 7.5 4 1.9
    经上表可知,窗口数从6变化到7时,∆W达到最大
    灵敏度Q(S,W)=(∆W⁄∆S)/(W⁄S)

    窗口数S 5 6 7 8 9 10 11
    灵敏度 0 2.02 3.82 5.86 7.80 8.90 8.13
    通过上表可以分析得知,平均排队时间W一定程度上受到了窗口数的影响,其中,窗口数为6、7、8时,平均排队时间减少量特别明显,窗口数为5时的时间为574秒,随后时间从429秒降到277秒。灵敏度随着窗口数量的增加而增大,在窗口数为7的位置等待时间的减少量达到最大,随后递减,可知,尽管10、11的灵敏度值较高,但是∆W很小,效率不算高。

    5、优化分析
    随着窗口数量的增加,学生的等待时间逐渐缩短;但是考虑到食堂方成本也会随之增加,窗口数量并不是越多越好。应当考虑双方,既要缩短排队时间,又要考虑成本和收益的关系。因此,对于窗口数的优化上,应当寻求一个可能的平衡点。
    寻求最佳的服务窗口数量S,使得系统总费用F(S)最小。
    S为窗口数量,F(S)所产生的费用,F_s为单位时间内平均每个窗口的费用,F_W为平均每个学生在系统中等待时间的损失,L是平均排队长。
    MinF(S)=F_s×S+F_W×L
    {█(ρ=λ/Sμ<1@F_s,S,F_W,L≥0)┤
    最佳的窗口数应当满足以下条件:
    {█(F(S_0)≤F(S_0-1)@F(S_0)≤F(S_0+1))┤

    由以上可得,
    L(S_0)-L(S_0+1)≤F_s/F_W ≤L(S_0-1)-L(S_0)
    食堂设有5个窗口,学生每分钟的到达强度为λ=3.38,ρ=λ/Sμ=4.45/S,若要满足ρ<1,则有S>4.45,这里我们取F_s/F_W =30,并采用边际分析法来分析。
    

    S L_q [L(S_0 )-L(S_0+1),L(S_0-1)-L(S_0 )]
    5 189.9
    6 140.8 [50.3,49.1]
    7 89.7 [39.2,51.1]
    8 49.8 [25.2,39.9]
    9 24.6 [13.7,25.2]
    10 10.9

    当窗口数为8时,
    L(S_0)=49.8,L(S_0+1)=24.6,L(S_0-1)=89.7,
    [L(S_0 )-L(S_0+1),L(S_0-1)-L(S_0 )]=[25.2,39.9], 
    

    经分析,在考虑学生等待时间与食堂方成本收益的前提下,此时的平均等待时间为160秒,每个窗口的排队学生数量为6,认为窗口数为8是比较合理的。

    6、结论
    S(窗口数量) L(平均排队的学生数) W_q(平均排队时间)

    Q
    5 189.91 57.48708312 0 0
    6 140.85 42.97208665 14.515 1 2.026664
    7 89.54 27.7915408 15.18055 1 3.823603
    8 49.81 16.03591957 11.75562 1 5.864645
    9 24.63 8.586093564 7.449826 1 7.808957
    10 10.96 4.542311636 4.043782 1 8.902476
    11 4.43 2.611662435 1.930649 1 8.131656

    窗口数为8时,系统中排队的学生数量为50人,每个窗口排队人数平均为6人,平均排队时间为160秒,灵敏度为5.86,学生等待时间相较于窗口数5时大幅度减少,且根据优化分析可知此时的运营成本是合理并可接受的,因此窗口数设置为8是符合学生食堂双方的利益的。

    总结
    通过利用运筹学排队论的相关知识,建立了多队多台排队模型,研究分析了食堂排队窗口数如何设置这一问题。排队论本身是一个理论化的模型,可能还有其他的因素没有考虑进去,但最后研究得出的结果也具有一定的参考性。当窗口数量增加时,学生等待时间随之减少,但窗口数越大并不能达到系统最优,应当寻求一个使得学生和食堂都能互利双赢的平衡点,既使得学生等待时长相对减少,又能降低食堂成本。建立一个高质量高效率的系统,不仅是学生的需求也是食堂的需求,也使得学校后勤保障制度更加完善。
    
    展开全文
  • 排队

    2009-03-07 11:48:00
    适用于服务行业办事大厅如金融、医院、邮政、通讯、工商、税务、车管、签证、保险、社保中心等单位排队叫号,能有效地改善服务环境,提高工作效率。触摸排队系统,操作简单,功能强大,外形精美。采用RS485总线连接...
  • 排队论模型

    万次阅读 多人点赞 2018-08-29 18:39:38
    排队论模型 1. 模型背景 排队论发源于上世纪初。当时美国贝尔电话公司发明了自动电话,以适应日益繁忙的工商业电话通讯需要。这个新发明带来了一个新问题,即通话线路与电话用户呼叫的数量关系应如何妥善解决,这...
  • 排队系统拥塞控制的位置

    万次阅读 2017-06-03 08:01:09
    前两篇文章,我零零散散地介绍了关于本地队列...然而这太零散了,如果你想将所有这一切融合在一个统一的框架中,会发现在它们之上的层次上还有很工作要做。本文为了这个目的写出,给出一个提纲挈领。顺便感谢一下与我
  • 排队论模型(二):生灭过程 、 M / M /s 等待制排队模型、服务台模型 排队论模型(三):M / M / s/ s 损失制排队模型 排队论模型(四):M / M / s 混合制排队模型 排队论模型(五): 有限源排队模型、服务...
  • 排队论模型及MATLAB实现

    万次阅读 多人点赞 2019-08-19 18:00:55
    排队现象3. 模型介绍3.1. 排队服务过程3.2. 排队系统的要素3.3. 顾客输入过程3.4. 排队结构与排队规则3.5. 服务机构与服务规则3.6. 服务台(员)为顾客服务的顺序3.7. 到达间隔和服务时间典型分布3.8. 排队模型示例...
  • 数学建模之排队

    万次阅读 多人点赞 2018-08-10 13:56:04
    排队是在日常生活中经常遇到的现象,如顾客到商店购买物品、病人到医院看病常 常要排队。此时要求服务的数量超过服务机构(服务台、服务员等)的容量。也就是说,到达的顾客不能立即得到服务,因而出现了排队现象。...
  • 模拟杂货店排队

    千次阅读 热门讨论 2020-02-09 19:20:45
    试题描述:该模拟程序中包含个队列,可以使用队列数组来模拟这些队列。假设杂货店共5条收银线,顾客可随机进入支付。顾客会进入最短的队伍,如果队伍一样长,那么选择最靠近的一个队伍。每次交易完成所消耗的时间...
  • 排队过程的一般表示 下图1就是排队过程的一般模型。各个顾客由顾客源(总体)出发,到达服务机构 (服务台、服务员)前排队等候接受服务, 服务完成后就离开。排队结构指队列的数目和排列方式 , 排队规则和服务规则是说明...
  • 1198 -- 排排队

    千次阅读 2015-09-02 15:10:08
    有一人,按1到n的顺序对这n个人进行编号。现在这n个人开始排队,有一个排队规则 就是编号为i的人不能站在第i位上,问:n个人进行排队,有多少种可能的排队方法? Input 包括组测试数据,每组测试数据包含一个...
  • 排队论入门学习 (for 数学建模)

    万次阅读 多人点赞 2017-08-29 22:26:17
    排队论入门学习 (for 数学建模)文字部分引用了很浙大数学建模排队论ppt中的内容,本人做个总结和代码实现为什么研究排队论?研究排队问题,就是要把排队的时间控制到一定的程度内,在服务质量的提高和成本的降低...
  • 分诊排队叫号

    千次阅读 2017-11-06 10:37:26
    分诊排队叫号系统主要目的是为了规范医院的就医秩序、节省人力物力、优化环境、提高工作效率以及服务品质。 2、软件服务对象 分诊排队叫号系统主要应用于: 1、 医院的医技类科室,比如超声科、放射科、心电图室...
  • 数模 04排队

    2019-07-19 10:25:04
    排队排队系统的组成: 1.输入过程: 输入过程是说明顾客按照怎样的规律到达系统,分为三个方面: 顾客总数:有限与无限 ...服务台数量及结构形式:数量上服务台有单台和台之分,结构形式上服...
  • 7-16 银行排队问题之单队列窗口服务 (25 分)

    千次阅读 多人点赞 2018-11-08 23:54:38
    7-16银行排队问题之单队列窗口服务(25分) 假设银行有ķ个窗口提供服务,窗口前设一条黄线,所有顾客按到达时间在黄线后排成一条长龙。当有窗口空闲时,下一位顾客即去该窗口处理事务。当有个窗口可选择时,...
  • 利用Redis实现排队需求

    千次阅读 2019-03-23 16:34:21
    利用Redis实现排队需求 近期在项目中做了一个用户排队等待接入客服的需求,此文记录自己的实现思路与过程,以及一些考虑的异常。 需求 大部分人都有排队等待接入客服的经历,所以需求不难理解:“存在一个在线客服...
  • 【AKOJ】1198-排排队

    2016-05-02 19:35:22
    排队 Time Limit:1000MS Memory Limit:65536K Total Submit:31 Accepted:29 ...包括组测试数据,每组测试数据包含一个整数n,代表一共有n个人进行排队 Output 包括一个整数,代表多少种可能的排队方法。 Sa
  • 当有个窗口可选择时,假设顾客总是选择编号最小的窗口。 本题要求输出前来等待服务的N位顾客的平均等待时间、最长等待时间、最后完成时间,并且统计每个窗口服务了多少名顾客。 输入格式: 输入第1行给出正整数N...
  • 自从苹果公司在轻视中国用户多年后突然脑筋急转弯,大举进军**市场,很国人的日子就变得充实起来。去年排队买iPhone 3GS,今年排队买iPhone 4;上个月排队买iPad,这个月排队买iPad 2;昨天已经排队买了iPhone 4,...
  • 医院排队候诊模型

    千次阅读 2017-11-22 12:30:23
    3. 每个科室需要安排一位医生或者护士,专门判断一下新来的病人病情的严重情况,这个判断不需要太时间,给出大致的情况即可。给出严重情况后,再排队。 4. 排队的病人按照次序,依次随机分配给正在空闲的医生...
  • 银行排队系统的设计与实现

    万次阅读 2013-06-16 22:49:21
     银行排队系统的设计与实现          学生姓名:*** 学 号:*** 年级专业及班级:**级计算机科学与技术(2)班 指导老师及职称:** 讲师 专 业:计算机科学与技术       *** 提交日期:2013年06月   ...
  • HTB分层令牌桶排队规则分析

    千次阅读 2014-12-14 04:16:39
    之前通过《默认FIFO_FAST出口排队规则分析》、《ingress入口排队规则分析》分析,已经对排队规则的基础架框有了简单的了解。那两种排队规则都是无类的,这里选出可以分类的HTB排队规则进行分析。 当前实例分析的...
  • 生活中需要排队的地方很,本模型用于分析和仿真现实生活中的排队现象。 排队论发源于上世纪初。当时美国贝尔电话公司发明了自动电话,以适应日益繁忙的工商业电话通讯需要。这个新发明带来了一个新问题,即通话...
  • 关于本文相信很多人都在节假日的高速公路上遇到过大拥堵,但是最终拥堵会解除。也有人在质疑路由器队列的长度,以为最终路由器会拒绝服务。... 因此本文旨在用最简单的描述分析一下排队理论对高速公路以

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,090
精华内容 15,236
关键字:

多列排队