精华内容
下载资源
问答
  • 数据结构中队列的运用
  • 数据结构C 银行客户平均等待时间
  • 8590 队列的应用——银行客户平均等待时间 时间限制:1000MS 代码长度限制:10KB 提交次数:2956 通过次数:1424 题型: 编程题 语言: G++;GCC Description 队列的基本操作如下: #include<malloc.h> #include<...

    8590 队列的应用——银行客户平均等待时间

    时间限制:1000MS 代码长度限制:10KB
    提交次数:2956 通过次数:1424

    题型: 编程题 语言: G++;GCC
    Description
    队列的基本操作如下:
    #include<malloc.h>
    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR 0
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等
    typedef int QElemType;
    #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1)

    typedef struct
    {
    QElemType *base; // 初始化的动态分配存储空间
    int front; // 头指针,若队列不空,指向队列头元素
    int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
    }SqQueue;

    Status InitQueue(SqQueue &Q)
    {
    // 构造一个空队列Q,该队列预定义大小为MAXQSIZE
    Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base) exit(1);
    Q.rear=Q.front=0;
    return OK;
    }

    Status EnQueue(SqQueue &Q,QElemType e)
    {
    // 插入元素e为Q的新的队尾元素
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
    }

    Status DeQueue(SqQueue &Q, QElemType &e)
    {
    // 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
    if(Q.front==Q.rear) return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return OK;
    }

    Status GetHead(SqQueue Q, QElemType &e)
    {
    // 若队列不空,则用e返回队头元素,并返回OK,否则返回ERROR
    if(Q.front==Q.rear) return ERROR;
    e=Q.base[Q.front];
    return OK;
    }

    int QueueLength(SqQueue Q)
    {
    // 返回Q的元素个数
    return Q.rear%MAXQSIZE-Q.front%MAXQSIZE;
    }
    某银行有一个客户办理业务站,在一天内随机地有客户到达,设每位客户的业务办理时间是某个范围内的值。设只有一个窗口,一位业务人员,要求程序模拟统计在
    一天时间内,所有客户的平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。

    输入格式
    第一行:一天内的客户总人数n
    第二行:第一个客户的到达时刻和需要办理业务的时间
    第三行:第二个客户的到达时刻和需要办理业务的时间
    ……
    第n行:第n - 1个客户的到达时刻和需要办理业务的时间
    第n + 1行:第n 个客户的到达时刻和需要办理业务的时间

    输出格式
    第一行:所有客户的平均等待时间(精确到小数点后2位)

    输入样例
    3
    1 3
    2 1
    3 5

    输出样例
    1.33

    注意这里会出现就是队伍已经没人了,但下一个人还没有来的情况

    #include<cstdio>
    #include "iostream"
    #include <cstdlib>
    #define OK 1
    #define ERROR 0
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等
    typedef int QElemType;
    #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1)
    using namespace std;
    typedef struct
    {
        QElemType *base; // 初始化的动态分配存储空间
        int front; // 头指针,若队列不空,指向队列头元素
        int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
    }SqQueue;
    
    Status InitQueue(SqQueue &Q)
    {
    // 构造一个空队列Q,该队列预定义大小为MAXQSIZE
    // 请补全代码
    Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    Q.front=Q.rear=0;
        return OK;
    
    }
    
    Status EnQueue(SqQueue &Q,QElemType e)
    {
    // 插入元素e为Q的新的队尾元素
    // 请补全代码
    if((Q.rear+1)%MAXQSIZE==Q.front)
    {
        return ERROR;
    }
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
        return OK;
    
    }
    
    Status DeQueue(SqQueue &Q, QElemType &e)
    {
    // 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
    // 请补全代码
    if(Q.rear==Q.front)
        return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
        return OK;
    }
    
    Status GetHead(SqQueue Q, QElemType &e)
    {
    // 若队列不空,则用e返回队头元素,并返回OK,否则返回ERROR
    // 请补全代码
    if(Q.rear==Q.front)
        return ERROR;
    e=Q.base[Q.front];
        return OK;
    
    }
    
    int QueueLength(SqQueue Q)
    {
    // 返回Q的元素个数
    // 请补全代码
        return abs(Q.front-Q.rear);
    
    }
    
    double QueueTraverse(SqQueue Q)
    {
    // 若队列不空,则从队头到队尾依次输出各个队列元素,并返回OK;否则返回ERROR.
        int i;
        double total = 0;
        i=Q.front;
        if(i==Q.rear)printf("The Queue is Empty!");  //请填空
        else{
            while(i!=Q.rear)     //请填空
            {
               // cout<<Q.base[i];
                total+=Q.base[i];
                i+=1;
            }
        }
       // cout<<total<<endl;
        return total;
    }
    
    int main()
    {
        double res;
        int leave;
        int stay;
        SqQueue Q;
        InitQueue(Q);
        int n;
        scanf("%d",&n);
        //n=n-1;
        int a,b;
        scanf("%d%d",&a,&b);
        EnQueue(Q,0);
        leave=a+b;
        for(int k=0;k<n-1;k++)
        {
            scanf("%d%d",&a,&b);
            stay=leave-a;
            //这里需要注意stay小于0的情况
            if(stay<0)
            {
                stay=0;
                leave=a+b;
            }
            else{
                leave=leave+b;
            }
            
            EnQueue(Q,stay);
        }
        res= QueueTraverse(Q)/(n);
        printf("%.2f",res);
    }
    
    展开全文
  • 设只有一个窗口,一位业务人员,要求程序模拟统计在一天时间内,所有客户平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。 Input 第一行:...
  • 一天时间内,所有客户平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。 输入格式 第一行:一天内的客户总人数n 第二行:第一个客户的...

    Description

    某银行有一个客户办理业务站,在一天内随机地有客户到达,设每位客户的业务办理时间是某个范围内的值。设只有一个窗口,一位业务人员,要求程序模拟统计在
    一天时间内,所有客户的平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。



     

    输入格式

    第一行:一天内的客户总人数n
    第二行:第一个客户的到达时刻和需要办理业务的时间
    第三行:第二个客户的到达时刻和需要办理业务的时间
    ……
    第n行:第n - 1个客户的到达时刻和需要办理业务的时间
    第n + 1行:第n 个客户的到达时刻和需要办理业务的时间


     

    输出格式

    第一行:所有客户的平均等待时间(精确到小数点后2位)


     

     

    输入样例

    3
    1 3
    2 1
    3 5


     

     

    输出样例

    1.33

     

    #define _CRT_SECURE_NO_WARNINGS
    #include<malloc.h>
    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR 0
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等
    typedef int QElemType;
    #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1)
    
    typedef struct
    {
    	QElemType *base; // 初始化的动态分配存储空间
    	int front; // 头指针,若队列不空,指向队列头元素
    	int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
    }SqQueue;
    
    Status InitQueue(SqQueue &Q)
    {
    	// 构造一个空队列Q,该队列预定义大小为MAXQSIZE
    	Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
    	if (!Q.base) exit(1);
    	Q.rear = Q.front = 0;
    	return OK;
    }
    
    Status EnQueue(SqQueue &Q, QElemType e)
    {
    	// 插入元素e为Q的新的队尾元素
    	if ((Q.rear + 1) % MAXQSIZE == Q.front) return ERROR;
    	Q.base[Q.rear] = e;
    	Q.rear = (Q.rear + 1) % MAXQSIZE;
    	return OK;
    }
    
    Status DeQueue(SqQueue &Q, QElemType &e)
    {
    	// 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
    	if (Q.front == Q.rear) return ERROR;
    	e = Q.base[Q.front];
    	Q.front = (Q.front + 1) % MAXQSIZE;
    	return OK;
    }
    
    Status GetHead(SqQueue Q, QElemType &e)
    {
    	// 若队列不空,则用e返回队头元素,并返回OK,否则返回ERROR
    	if (Q.front == Q.rear) return ERROR;
    	e = Q.base[Q.front];
    	return OK;
    }
    
    int QueueLength(SqQueue Q)
    {
    	// 返回Q的元素个数
    	return Q.rear%MAXQSIZE - Q.front%MAXQSIZE;
    }
    
    double Qsum(SqQueue Q)
    {
    	double sum = 0.0;
    	while (Q.front != Q.rear)
    	{
    		sum += Q.base[Q.front];
    		Q.front = (Q.front + 1) % MAXQSIZE;
    	}
    	return sum;
    }
    
    int main()
    {
    	SqQueue Q;
    	InitQueue(Q);
    	int n = 0;
    	int arrive, need, wait;
    	int curtime;
    	double sum = 0.0;
    	scanf("%d", &n);
    
    	scanf("%d %d", &arrive, &need);
    	curtime = arrive + need;//时间推进到第一个人办理完
    	EnQueue(Q, 0);//第一个人无需等待
    	for (int i = 1;i < n;i++)
    	{
    		scanf("%d %d", &arrive, &need);
    		wait = curtime - arrive;//等待时间为前一人办完时间和他到达时间之差,但恒大于0;
    		if (wait < 0)
    		{
    			wait = 0;
    			curtime = arrive + need;//若这个人不需等待,时间置为他办理完
    		}
    		else
    			curtime += need;//若这个人需要等待,时间增加他的办理时间
    		EnQueue(Q, wait);
    	}
    	printf("%.2f", Qsum(Q) / n);//Qsum计算总等待时间
    	return 0;
    }

     

    展开全文
  • 如果当前顾客的到达时刻 cli [i] [0] 小于这个cur,那就说明他必须要等上一位顾客搞定才轮得到他,这个cur减 cli [i] [0] 就能得到当前顾客的等待时间, 第二种情况: 如果当前顾客的到达时刻 cli [i] [0] 大于这个...

    思路:首先用一个cur用来表示上一位顾客完成业务办理的时刻,

    第一种情况:

    如果当前顾客的到达时刻 cli [i] [0] 小于这个cur,那就说明他必须要等上一位顾客搞定才轮得到他,这个cur减 cli [i] [0] 就能得到当前顾客的等待时间,

    第二种情况:

    如果当前顾客的到达时刻 cli [i] [0] 大于这个cur,说明他根本不用等,因为上一个顾客搞完很久了,这时候相当于当前顾客是第一个顾客,不用排队,于是cur就得修改成 cli [i] [0] + cli [i] [1]

    #include<malloc.h>
    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define ERROR 0
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等
    typedef float QElemType;
    #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1)
    using namespace std;
    float cli[1000][2];
    typedef struct
    {
       QElemType *base; // 初始化的动态分配存储空间
       int front; // 头指针,若队列不空,指向队列头元素
       int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
     }SqQueue;
     
    Status InitQueue(SqQueue &Q)
    {
    // 构造一个空队列Q,该队列预定义大小为MAXQSIZE
    	Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    	if(!Q.base) exit(1);
    	Q.rear=Q.front=0;
    	return OK;
    }
    
    Status EnQueue(SqQueue &Q,QElemType e)
    {
    // 插入元素e为Q的新的队尾元素
    	 if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;
    	 Q.base[Q.rear]=e;
    	 Q.rear=(Q.rear+1)%MAXQSIZE;
    	 return OK;
    }
    
    Status DeQueue(SqQueue &Q, QElemType &e)
    {
    // 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
    	 if(Q.front==Q.rear) return ERROR;
    	 e=Q.base[Q.front];
    	 Q.front=(Q.front+1)%MAXQSIZE;
    	 return OK;
    }
    
    int QueueLength(SqQueue Q)
    {
    // 返回Q的元素个数
    	return Q.rear%MAXQSIZE-Q.front%MAXQSIZE;
    }
    
    int main()
    {
        SqQueue q;
        InitQueue(q);
        float e,sum,cur=0;
        int n;
        cin>>n;
        for(int i=0;i<n;i++)
        {
            cin>>cli[i][0]>>cli[i][1];//第i个顾客的到达时刻和办理时间的输入
            if(i!=0) EnQueue(q,cli[i][0]);
        }
        
        cur=cli[0][0]+cli[0][1];
        
        for(int i=1;i<n;i++)
        {
            DeQueue(q,e);
            if(cli[i][0]<cur){sum+=cur-e;cur+=cli[i][1];}
            else cur=cli[i][0]+cli[i][1];
        }
        printf("%.2f",sum/n);
        return 0;
    }
    
    

    u1s1,个人感觉这个题你甚至可以不用队列,我觉得只是为了用队列而用队列,当然可能是我没领会到队列精髓所在…还有就是这道题题目说的不太好,我一开始以为等待时间是加上办理业务的时间的,后来发现只是计算排队时间

    展开全文
  • 第一个顾客等待时间为0; 第二个顾客到达时间为2,办理业务时间为4,等待时间为2,; 第三个顾客,到达时间为3,开始办理业务时间为5,等待时间为2; 所以是4/3 */ // QElemType已经重新定义为float 为了配合后面的...
    /*
    例子的1.33是怎么算出来的 ? 
    第一个顾客等待时间为0;
    第二个顾客到达时间为2,办理业务时间为4,等待时间为2,;
    第三个顾客,到达时间为3,开始办理业务时间为5,等待时间为2;
    所以是4/3
    */
    
    // QElemType已经重新定义为float 为了配合后面的相关参数
    
    #include <malloc.h>
    #include <stdio.h>
    #include <stdlib.h>
    #define OK 1
    #define ERROR 0
    typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等
    typedef float QElemType;
    #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1)
    
    typedef struct
    {
        QElemType *base; // 初始化的动态分配存储空间
        int front;       // 头指针,若队列不空,指向队列头元素
        int rear;        // 尾指针,若队列不空,指向队列尾元素的下一个位置
    } SqQueue;
    
    Status InitQueue(SqQueue &Q)
    {
        // 构造一个空队列Q,该队列预定义大小为MAXQSIZE
        Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
        if (!Q.base)
            exit(1);
        Q.rear = Q.front = 0;
        return OK;
    }
    
    Status EnQueue(SqQueue &Q, QElemType e)
    {
        // 插入元素e为Q的新的队尾元素
        if ((Q.rear + 1) % MAXQSIZE == Q.front)
            return ERROR;
        Q.base[Q.rear] = e;
        Q.rear = (Q.rear + 1) % MAXQSIZE;
        return OK;
    }
    
    Status DeQueue(SqQueue &Q, QElemType &e)
    {
        // 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
        if (Q.front == Q.rear)
            return ERROR;
        e = Q.base[Q.front];
        Q.front = (Q.front + 1) % MAXQSIZE;
        return OK;
    }
    
    Status GetHead(SqQueue Q, QElemType &e)
    {
        // 若队列不空,则用e返回队头元素,并返回OK,否则返回ERROR
        if (Q.front == Q.rear)
            return ERROR;
        e = Q.base[Q.front];
        return OK;
    }
    
    int QueueLength(SqQueue Q)
    {
        // 返回Q的元素个数
        return Q.rear % MAXQSIZE - Q.front % MAXQSIZE;
    }
    
    int main()
    {
        float client[1000][2];       //一个1000行 2列的二维数组,第一列存放顾客的到达时间,第二列存放顾客的办理业务所需时间
        float sum = 0;               //用来存放等待时间
        float previous_client_timoe; //前一个顾客办完业务的时间点
        float e;                     //接收出队顾客的到达时间
        int n;                       //顾客人数
        SqQueue Q;
        InitQueue(Q); //初始化排队队列
        int i;        //控制循环
    
        scanf("%d", &n);
        for (i = 0; i < n; i++)
        {
            scanf("%f %f", &client[i][0], &client[i][1]); //接收客户两个数据,到达时刻和需要办理业务的时间。
        }
    
        for (i = 1; i < n; i++)
        {
            EnQueue(Q, client[i][0]); //客户的到达时间开始进入队列,第一顾客就不用进队
        }
    
        previous_client_timoe = client[0][0] + client[0][1]; //算出第一个顾客的办完业务的时间点
        for (i = 1; i < n; i++)
        {
            DeQueue(Q, e);
            if (e < previous_client_timoe) //if判断是true就是  顾客在前一个顾客办完业务的时间点前就到达了要等待
            {
                sum += (previous_client_timoe - e);
                previous_client_timoe = previous_client_timoe + client[i][1];  //更新新的前一个顾客办完业务的时间点, 旧的时间+客户办理业务所需时间
            } 
            else  //flase 不用等待
            {
                previous_client_timoe = client[i][0] + client[i][1];
            }
        }
        printf("%.2f\n", sum / n);
        return 0;
    }
    
    /*
    某银行有一个客户办理业务站,在一天内随机地有客户到达,设每位客户的业务办理时间是某个范围内的值。设只有一个窗口,一位业务人员,要求程序模拟统计在
    一天时间内,所有客户的平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。
    
    
    
    输入格式
    第一行:一天内的客户总人数n
    第二行:第一个客户的到达时刻和需要办理业务的时间
    第三行:第二个客户的到达时刻和需要办理业务的时间
    ……
    第n行:第n - 1个客户的到达时刻和需要办理业务的时间
    第n + 1行:第n 个客户的到达时刻和需要办理业务的时间
    
    
    输出格式
    第一行:所有客户的平均等待时间(精确到小数点后2位)
    
    
    输入样例
    3
    1 3
    2 1
    3 5
    
    
    输出样例
    1.33
    */

     

    展开全文
  • python 银行平均等待时间 class ATM(): def __init__(self, maxtime = 5): self.t_max = maxtime def getServCompleteTime(self, start = 0): return start + random.randint(1, self.t_max) cla...
  • 但往往会有其他队列办事速度快,队列长度很快变得比你所在队列的还短,但你改变自己的队列去当前较短的队列时,可能没过多久刚刚你在的队列又比你现在所处的队列短了,因为队短不代表等待时间短,你无法预测每个队列...
  • 每个窗口只有一个客户正在办理手续,其它客户都在等待等待且根据到达事件进行排序,当某个窗口的客户办完业务时,将等待区的最先到达的客户安排到刚空闲下来的窗口去办理业务。这样显然提高了时间利用效率,且先...
  • 存储客户事件,包括到达事件和离开事件,其中到达事件的事件类型为0,1号窗口的离开事件类型为1,二号窗口的离开事件类型为2,三号窗口的离开事件类型为3,四号窗口的离开事件类型为4,由此就可以只使用事件类型就将到达...
  • 个人业务窗口也分为金卡窗口和普通卡窗口,金卡窗口有金卡客户等待叫号时只为金卡用户服务, 普通卡窗口在有普通卡用户等待叫号时置为普通卡用户服务.  假定某银行对一个储蓄所做了调查统计,总结出顾客到达的时间...
  • 正如标题所示的意思,该程序的目的是要模拟,银行客户办理业务所花费的平均时间。 该程序是事件驱动程序,按照事件驱动的思路进行。如此,首先需要建立一个事件列表,其中存储着按事件发生的时间顺序排列的事件,...
  • //银行客户平均等候时间//要算等候时间和算逗留时间是不同的//t1[i]表示第i个人的到达时间,t[i]表示第i个人办理时间,t2[i]表示第i个人离开时间,time[i]表示第i个人的等候时间//我们要算平均等候时间,其实就是time...
  • 一天时间内,所有客户平均等待时间。模拟数据按客户到达的先后顺序依次由键盘输入,对应每位客户有两个数据,到达时刻和需要办理业务的时间。 输入格式 第一行:一天内的客户总人数n 第二行:第一个客户的到达时刻...
  • 背景:随机数在离散事件模拟中对于生成事件时间非常重要。随机数链必须具有两个主要属性:1)均匀性2)独立性。随机仿真模型需要一个或多个随机变量作为输入。可以从一个随机变量(例如X)生成随机数。当可能结果的...
  • 1017 PAT 排队的实质是时间之差,想不排队就要晚来?!
  • Python 实例详解:银行 ATM 等待时间分析

    千次阅读 多人点赞 2018-11-05 14:50:39
    假设银行有 1 台 ATM 机,共 n 位客户来银行操作 ATM 机器,求客户平均的排队等候时间。 【逻辑梳理】 ATM 机操作时间由客人选择的办理业务决定,符合随机分布。 客户流到达银行时间不定,符合随机分布。 ...
  • 假设当对私窗口等待服务的客户(按实际服务窗口)平均排队人数超过(大于或等于)7人时,等待客户将可能有抱怨,影响服务质量,此时银行可临时将其它窗口中一个或两个改为对私服务,当客户少于7人时,将立即恢复原有...
  • 假设每个客户在取款之前先拿号排队,然后在任意一个 柜台有空闲的时候,号码数最小的客户上去办理,假设所有的客户拿到号码之后都不会失去耐心走掉 , 请写程序计算所有客户平均等待时间。 那么这道题的解决思路是...
  • 要求程序模拟统计在一天时间内,所有客户平均等待时间。 模拟数据按客户到达的先后顺序依次由键盘输入, 对应每位客户有 两个数据,即 到达时刻 和 需要办理业务(占用)的时间。 测试样例格式说明: [键盘输入] 第...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,469
精华内容 2,187
关键字:

银行客户平均等待时间