精华内容
下载资源
问答
  • 2019-09-18 22:54:06
    • 统计出,最小等待时间、最大等待时间、平均等待时间、90%账单等待时间;
    • 最小等待时间、最大等待时间 不排除等待时间<=0的账单;
    • 平均等待时间、90%账单等待时间 要剔除掉等待时间<=0的账单
    SELECT 
    		    MIN(useTimeMinute) AS minUseTimeMinute, # 最小耗时
    		    MAX(useTimeMinute) AS maxUseTimeMinute, # 最大耗时
    		    ROUND(AVG(IF(useTimeMinute > 0, useTimeMinute, NULL))) AS avgUseTimeMinute,# 平均耗时
    		    @normalBillNum AS nomralBillCount, # 正常单总数
    		    MAX(IF(normal_bill_num = CEIL(@normalBillNum * 0.9), useTimeMinute, NULL)) AS universalUseTime # 普遍耗时(取第90%个正常单的耗时)
    		FROM (
    		SELECT
    		    bill.bill_id,
    		    bill.suggest_prepare_time, # 建议完成时间
    		    bill.real_prepare_time, # 实际完成时间
    		    CEIL(TIMESTAMPDIFF(SECOND, bill.suggest_prepare_time, bill.real_prepare_time) / 60) AS useTimeMinute, # 秒转分钟,舍尾取整
    		    IF(TIMESTAMPDIFF(SECOND, bill.suggest_prepare_time, bill.real_prepare_time) <= 0, -1, @normalBillNum := @normalBillNum + 1) AS normal_bill_num # 非正常单序号特殊标记为-1,正常单号正数序号排序     
    		FROM
    		    c_bill bill,
    		(SELECT (@normalBillNum := 0)) row_number_tmp		
    			ORDER BY useTimeMinute ASC
    		) a 
    

     

    转载于:https://my.oschina.net/zhendy/blog/3065654

    更多相关内容
  • 最小平均等待时间

    千次阅读 2014-05-14 20:52:32
    最小平均等待时间    题目描述 有n个顾客同时在等待一项服务,顾客i需要的服务时间为ti,1≤i≤n。要安排一个服务次序使得平均等待时间最小(平均等待时间是n个顾客等待服务时间的总和除以n)。请编写算法,...
                                                                                                    最小平均等待时间
     
                                                                                           题目描述
    有n个顾客同时在等待一项服务,顾客i需要的服务时间为ti,1≤i≤n。要安排一个服务次序使得平均等待时间最小(平均等待时间是n个顾客等待服务时间的总和除以n)。请编写算法,计算最小平均等待时间。
    输入
    第一行为测试用例个数m,m≤1000。 第二行开始为m个测试用例,每个测试用例由一组空格间隔的整数组成,第一个整数n为顾客的人数,后面n个整数为每个顾客需要的服务时间t,0<m≤1000,0<t≤1000。
    输出
    对每个测试用例,输出最小平均等待时间的整数部分(舍去小数部分),每个输出占一行。
    样例输入
    2
    5 15 9 3 14 3
    10 13 3 12 9 6 9 1 91 44 32
    样例输出
    10

    36

    #include<iostream>
    #include<algorithm>
    using namespace std;
    int main()
    {
         int n;
         int m;
         int sum;
         int x[1020];
         cin>>n;
         while (n--)
         {
             cin>>m;
             for ( int i=0;i<m;i++)
             {
                 cin>>x[i];
             }
             sort(x,x+m);
             sum=0;
             for ( int j=0;j<m;j++)
             {
                 sum+=x[j]*(m-1-j);
             }
             cout<<sum/m<<endl;
         }
         return 0;
    }

    即是由小到大排序,先进行短时间任务,然后分别乘以等待个数,利用循环即可

    展开全文
  • 最小平均等待时间[未解决]

    千次阅读 2019-04-01 22:30:05
    排序后,最短等待时间其实就是每个人的等待时间之和。 实例1: 4 ---------------------------------->单线程 91 13 43 44-------------------->排序:13 43 44 91 输出:169---------------------->等待...

    小的放前面?----->排序后,最短等待时间其实就是每个人的等待时间之和。

    实例1:

    4 ---------------------------------->单线程

    91 13 43 44-------------------->排序:13 43 44 91

    输出:169---------------------->等待时间:0 13 13+43 13+43+44

    输出=13*(4-1)+43*(4-2)+44*(4-3)

    实例2:

    根据平均等待时间的概念,将所有进程的等到时间加起来,除以进程数,就可以了。
    根据平均周转时间的概念,将所有进程的等待、执行时间加起来,除以进程数,就可以了。[判断进程中等待时间最小的执行]

     输入样例

    10 2

    56 12 1 99 1000 234 33 55 99 812--------->1 12 33 55 56 99 99 234 812 1000

    输出样例

    336.000---------------------------------------------->等待时间总和为线程等待总时间的和 645+314=969 /10??

    转自: https://blog.csdn.net/sdz20172133/article/details/79223628 

    参考 https://blog.csdn.net/abc1498880402/article/details/83714229 

    参考https://blog.csdn.net/qq_40956679/article/details/83687612

     

     

    展开全文
  • (1)问题描述:  设有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti, 1。应如何安排n个顾客的服务... 计算出的最小平均等待时间。 (5)输入示例 10  56 12 1 99 1000 234 33 55 99 812 (6)输出示例 532.00
  • 做题的过程中,因为没有正确地处理迭代器失效的问题浪费了好多时间(>﹏ 轮询调度算法 如果一个系统可以在单个CPU上运行多个并发作业,那么就该系统而言,“调度”是指:系统选择运行哪些任务,何时运行,何时...
    今天做 亚信的笔试题遇到的轮询调度算法,和春招做的百度笔试题短作业优先调度算法很相似,但是难度要UPUP。做题的过程中,因为没有正确地处理迭代器失效的问题浪费了好多时间(>﹏<。)~,看来有必要把STL再看一遍了!不废话了,直接上题目。
    轮询调度算法
    如果一个系统可以在单个CPU上运行多个并发作业,那么就该系统而言,“调度”是指:系统选择运行哪些任务,何时运行,何时中断以及以何种方式运行或中断。轮询调度规则是指:每个作业运行时间固定,该作业结束后,切换到下一个作业。一个作业的等待时间是指运行前需要等待的总时间。每个作业会在特定时间到达,等待调度,并占用一段固定时间运行。新作业到达后系统会把该作业正在等待CPU的现有作业之后。
    题目描述:
    给定提交列表,使用轮询策略计算所有作业的平均等待时间。函数wait_time_robin包含两个含有作业到达时间arrival和作业运行时间run的整数数组,还有一个表示作业数的整数n,和一个表示轮询策略使用的固定时长得整数q。作业到达时间和作业运行时间根据作业到达时间升序排列。对于同时到达的作业,按照其在到达时间数组中的顺序处理,可以假设,作业到达时,CPU一直未空闲。返回值为使用轮询策略算出的作业平均等待时间(浮点数)。

    假设 0 <= 作业到达时间 < 100 且 0  < 作业运行时间 < 100。

    #include <iostream>
    #include <vector>
    using namespace std;
    
    float wait_time_robin(int *arrival, int *run, int n, int q)
    {
        vector<int> wait_queue;//等待队列 存放还没运行的任务
        vector<int> task_queue;//任务队列 存放正在运行的任务
    
        int cur_time = 0;
        int *predict_end_time = new int[n];//预计结束的时间
        int *actual_end_time = new int[n];//实际结束的时间
        int *run_time = new int[n];
    
        for (int i = 0; i < n; i++)
        {
            predict_end_time[i] = arrival[i] + run[i];
            wait_queue.push_back(i);
            run_time[i] = run[i];
        }
    
        while (wait_queue.size() != 0 || task_queue.size() != 0)
        {
            for (vector<int>::iterator iter1 = wait_queue.begin(); iter1 != wait_queue.end();)
            {
                if (arrival[*iter1] <= cur_time)
                {
                    task_queue.push_back(*iter1);//如果有任务到来,则把该任务从等待队列转到任务队列
                    iter1 = wait_queue.erase(iter1);
                }
                else
                {
                    iter1++;
                }
            }
    
            if (wait_queue.size() > 0 && task_queue.size() == 0)//正在运行的任务队列里没有任务,等待队列里还有任务,但是任务还没来
            {
                cur_time++;
            }
    
            for (vector<int>::iterator iter2 = task_queue.begin(); iter2 != task_queue.end();)//依次处理任务队列的任务
            {
                if (run_time[*iter2] > q)//该任务剩余运行时间大于调度时间
                {
                    cur_time += q;
                    run_time[*iter2] -= q;
                }
                else//该任务剩余运行时间小于于调度时间
                {
                    cur_time += run_time[*iter2];
                    run_time[*iter2] = 0;
                    actual_end_time[*iter2] = cur_time;//记录下该任务实际完成时间
                }
                int index  = *iter2;//在下面可能有push_back操作会导致iter2失效,故先保存下来
                task_queue.erase(iter2);//当前任务已经运行过,从队头移除
    
                for (vector<int>::iterator iter1 = wait_queue.begin(); iter1 != wait_queue.end();)
                {
                    if (arrival[*iter1] <= cur_time)
                    {
                        task_queue.push_back(*iter1);//这里会导致iter2迭代器失效
                        iter1 = wait_queue.erase(iter1);
                    }
                    else
                    {
                        iter1++;
                    }
                }
    
                if (run_time[index] > 0)//当前任务还没运行完
                {
                    task_queue.push_back(index);//添加到任务队列后面
                }
    
                iter2 = task_queue.begin();//iter2重新指向队头
            }
    
        }
    
        float sum_time = 0;
    
        for ( i = 0; i < n; i++)
        {
            sum_time = sum_time + actual_end_time[i] - predict_end_time[i];//等待时间 = 实际结束时间- 预计结束时间
        }
    
        delete []predict_end_time;
        delete []actual_end_time;
        delete []run_time;
    
        return sum_time / n;
    }
    
    int main(int argc, char* argv[])
    {
        int arrival[]= {10, 11, 14};
        int run[] = {5, 2, 3};
        cout << wait_time_robin(arrival, run, 3, 3) << endl;
        return 0;
    }
    短作业优先调度算法(SJF)
    短作业优先调度算法(Short Job First)用于进程调度时又被称为短进程优先调度算法(Short Process First),该算法既可以用于作业调度,又可以用于进程调度。 
    在作业调度中,该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业,将他们调入内存,分配必要的资源,创建进程并放入就绪队列。在进程调度中的原理类似。
    问题描述:
    假设有n项作业位于就绪队列中,这些作业的提交时间用数组arrival按照提交时间的先后顺序存储,对应的作业服务时间(持续时间)用数组run存储。采用SJF算法,计算n项作业的平均等待时间。当存在多个相同长度的短作业时,按照提交时间的先后顺序进行调度。假设0<= n <= 100。

    #include <iostream>  
    #include <vector>  
    using namespace std;  
    
    float min_wait_time(int *arrival, int *run, int n)
    {
        vector<int> wait_queue;//等待队列
        vector<int> task_queue;//任务队列
        int *predict_end_time = new int[n];//预计结束的时间  
        int *actual_end_time = new int[n];//实际结束的时间  
    
        int cur_time = 0;
        for (int i = 0; i < n; i++)  
        {   
            predict_end_time[i] = arrival[i] + run[i];  
            wait_queue.push_back(i); 
        }
    
        while (wait_queue.size() != 0 || task_queue.size() != 0)
        {
            if (wait_queue.size() > 0 && arrival[(*wait_queue.begin())] <= cur_time)//有新任务到来,加到任务队列中
            {
                for (vector<int>::iterator iter = wait_queue.begin(); iter != wait_queue.end();)
                {
                    if (arrival[*iter] <= cur_time)
                    {
                        task_queue.push_back(*iter);
                        iter = wait_queue.erase(iter);
                    }
                    else
                    {
                        break;
                    }
                }
    
            }
            else if (task_queue.size() > 0)//任务队列有任务,执行任务
            {
                vector<int>::iterator min_iter = task_queue.begin();
                for (vector<int>::iterator iter = task_queue.begin(); iter != task_queue.end(); iter++)
                {
                    if (run[*iter] < run[*min_iter])//记录下用时最少的
                    {
                        min_iter = iter;
                    }
                }
                cur_time += run[*min_iter];//执行任务
                actual_end_time[*min_iter] = cur_time;//记录下实际完成时间
                task_queue.erase(min_iter);
            }
            else//如果任务队列里没任务,等待队列里有任务但未到来
            {
                cur_time++;
            }
        }
        float sum_time = 0;  
    
        for ( i = 0; i < n; i++)  
        {  
            sum_time = sum_time + actual_end_time[i] - predict_end_time[i];//等待时间 = 实际结束时间- 预计结束时间  
        }  
    
        delete []predict_end_time;  
        delete []actual_end_time;  
    
        return sum_time / n;  
    }
    
    int main(int argc, char* argv[])  
    {  
    
        int arrival[]= {0, 2, 4, 25};  
        int run[] = {7, 4, 1, 4};
    
        cout << min_wait_time(arrival, run, 4) << endl;
    
        return 0;  
    } 
    
    
    


    展开全文
  • 短作业优先调度算法(SJF)  短作业优先调度算法... 在作业调度中,该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业,将他们调入内存,分配必要的资源,创建进程并放入就绪队列。在进程调度中
  • //计算出最小平均等待时间 result=result/s; cout平均最短等待时间为:"; } 核心问题: 要做一个服务点的很简单,只需要用一个vector把数据存起来再累加就好了,麻烦的是有多处服务点,就得用两个vector来体现二维...
  • 应如何安排n个顾客的服务次序才能使平均等待时间达到最小平均等待时间是n个顾客等待服务时间的总和除以n。 ¢ 给定的n个顾客需要的服务时间和s的值,编程计算最优服务次序。 ¢ 输入 第一行有2个正整数n和s,...
  • 磁盘平均等待时间,又叫潜伏期,是指磁头已处于要访问的磁道,等待所要访问的扇区旋转至磁头下方的时间。平均等待时间为盘片旋转一周所需的时间的一半。 平均等待时间为盘片旋转一周所需的时间的一半,因此我们先求...
  • 用贪心算法解决最优服务次序问题,即顾客平均等待时间最少
  • 直接上代码: #include<...//顾客等待时间采用的冒泡排序法: int paixu(int cnum) { int i,j; int sum=0; for(i=0;i<cnum-1;i++) { for(j=i;j<cnum;j++) { if(a[i]>a[j]) {...
  • 应该如何安排n个顾客的服务次序才能使平均等待时间达到最小?问题描述二:一辆汽车加满油后,可行使n千米。旅途中有若干个加油站。若要使沿途加油次数最少,设计一个有效算法,对于给定的n和k个加油站位置,指出应在...
  • 调查结果表明,超出预定到达时间的最小可接受等待时间为1分钟,而最大可接受等待时间据报告为20分钟。 而且,在接受调查的顾客总数中,只有三分之一(33%)愿意在预定的公共汽车到达时间后等待最多5分钟。 另外,...
  • 最优服务次序问题 设有n 个顾客同时等待同一项服务顾客i 需要的服务时间为ti,1应如何安排n 个顾客的服务次序才能使平均等待时间达到最小平均等待时间 是n 个顾客等待服务时间的总和除以n 参考答案 一最优服务次序...
  • 问题描述: 设有n(1≤n≤100)个顾客同时等待一项服务。顾客i需要的服务时间为ti,1≤i≤n,共有s处提供此服务。应如何安排n个顾客的服务...编写一个贪心算法,计算n个顾客的最小平均等待时间及各处的顾客服务次序。
  • 设T为任意一种调度策略产生的平均周转时间,则 Ti是第i+1个执行的进程的运行时间. 对T0,T1,...,Tn-1递增排序,得Tk0 , Tk1, …… ,Tkn-1,设T'位SJF策略生成的调度方案的平均周转时间,则: T' = [ Tk0 + ...
  • 贪心算法(3):最优服务次序问题

    千次阅读 2019-05-06 21:19:01
    应如何安排n个顾客的服务次序才能使平均等待时间达到最小?平均等待时间是n 个顾客等待服务时间的总和除以n。 样例 输入: 10 56 12 1 99 1000 234 33 55 99 812 输出: 532.00 题解 每次让占用时间最少的人先上,注意求...
  • n个顾客等待时间最短(贪心算法)

    万次阅读 2018-11-04 11:16:35
    应如何安排n个顾客的服务才能使平均等待时间达到最短?平均的带时间时n个顾客等待服务时间的总和除以n。 方法:先按从大到小排序,然后再挨个排队。 package 实验四; import java.util.Arrays; public class 等待...
  • 首先我们要知道: 套用上述公式计算 3、求出最佳调度方案,最小平均延迟及流水线的最大吞吐率 1、写出预约表的延迟禁止表和冲突向量C 延迟禁止表的定义:将流水线中所有各段对一个任务流过时会争用同一段的节拍间隔...
  • t2 平均周转时间 = (总的运行时间 + 总的等待时间)/n其中总的运行时间是定值,n为定值,因此要平均周转时间最短既要求总的等待时间最短。按照最短作业优先,设第i个作业的等待时间为ai.则a1 = 0a2 = t1a3 = t1 + t2...
  • 最优服务次序问题-贪心算法

    千次阅读 2018-05-08 18:22:35
    应如何安排n个顾客的服务次序才能使平均等待时间达到最小?平均等待时间是n 个顾客等待服务时间的总和除以n。(2)编程任务: 对于给定的n个顾客需要的服务时间,编程计算最优服务次序。(3)数据输入: 第一行是正...
  • 问题描述:设有n个顾客同时等待一项服务。顾客i需要的服务时间为ti,1£ i £n 。应如何安排n个顾客的服务次序才能使平均等待时间达到最小?...将编程计算出的最小平均等待时间输出到文件output.o...
  • printf("客户的平均等待为其办理业务的时间是: %f minutes\n", (float) WaitTime/CustomerNum ); } 5、到达事件处理函数: voidCustomerArrived( ); 1)到达客户总数加1,利用随机数生成函数生成下一个...
  • 最优服务次序问题

    千次阅读 2010-11-30 22:42:00
    描述 <br />设有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti,1≤i ≤n。应如何安排n个顾客的服务次序才能使平均... 输出 将编程计算出的最小平均等待时间输出。 样例输入 10
  • Java(顾客最短等待时间

    千次阅读 2018-11-07 14:15:24
    应如何安排n个顾客的服务次序才能使得平均等待时间达到最小平均等待时间是n个顾客等待时间的总和除以n。 代码如下: package TXSF; import java.util.Scanner; public class ZY { public static vo...
  • poisson(泊松过程)的Matlab仿真包括poisson分布,及相关函数,平均值,均方差等
  • 有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti, 1≦i ≦n 。共有s处可以提供此服务。应如何安排n个顾客的服务次序才能使平均等待时间达到最小?平均等待时间是n 个顾客等待服务时间的总和除以n。
  • 硬盘转速和平均寻道时间

    万次阅读 2017-05-08 12:45:26
    设一个磁盘的平均寻道时间为20ms...答案:读写一个512字节的扇区的平均时间为28.1ms平均旋转延时 = 0.5/5400转/分 = 0.0056秒 = 5.6ms平均磁盘访问时间 = 平均寻道时间 + 平均旋转延时 + 传输时间 + 控制器延时 = 20ms
  •  上面这张图是应用其他人的关于并发用户数,QPS,用户平均等待时间的一张关系图,对于实际的系统,也应该是对于不同的并发数,进行多次 测试 ,获取到这些数值后,画出这样一张图出来,以便于分析出系统的最佳并发...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,595
精华内容 21,038
关键字:

最小平均等待时间