Queueing at Bank (25)

package go.jacob.day922;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt(), K = sc.nextInt();
        ArrayList<Customer> list = new ArrayList<Customer>();
        int[] windows = new int[K];
        // 记录等待时间
        int waitTime = 0;
        // 将17:0:0前到达的顾客存入list
        for (int i = 0; i < N; i++) {
            String time = sc.next();
            int needTime = sc.nextInt();
            // 说明超时到达
            if (time.compareTo("17:00:00") > 0)
                continue;
            String[] arr = time.split(":");
            int h = Integer.parseInt(arr[0]), m = Integer.parseInt(arr[1]), s = Integer.parseInt(arr[2]);
            int arriveTime = h * 3600 + m * 60 + s;
            if (arriveTime < 8 * 3600) {
                waitTime += 8 * 3600 - arriveTime;
            }
            list.add(new Customer(arriveTime, needTime));
        }
        // 按到达时间排序
        Collections.sort(list, new Comparator<Customer>() {
            @Override
            public int compare(Customer c1, Customer c2) {
                return c1.arriveTime - c2.arriveTime;
            }
        });
        for (int i = 0; i < list.size(); i++) {
            Customer c = list.get(i);
            int w = findFreeWindow(windows, c);
            // 找到空闲窗口
            if (w >= 0) {

                if (c.arriveTime < 8 * 3600) {
                    windows[w] = 8 * 3600 + c.needTime;
                } else {
                    windows[w] = c.arriveTime + c.needTime;
                }
            } else {// 不存在空闲窗口，顾客需要等待
                w = findFirstFreeWindow(windows);
                //因为之前waitTime已经加上相对8点的等待时间，所以这里必须判断
                if (c.arriveTime < 8 * 3600) {
                    waitTime += windows[w] - 8 * 3600;
                    windows[w] += c.needTime;
                } else {
                    waitTime += windows[w] - c.arriveTime;
                    windows[w] += c.needTime;
                }
            }
        }
        System.out.printf("%.1f", waitTime / 60.0 / list.size());
        sc.close();
    }

    private static int findFirstFreeWindow(int[] windows) {
        int first = 0;
        for (int i = 1; i < windows.length; i++) {
            if (windows[i] < windows[first])
                first = i;
        }
        return first;
    }

    // 试图找到当前顾客可以直接进入的窗口
    private static int findFreeWindow(int[] windows, Customer customer) {
        for (int i = 0; i < windows.length; i++) {
            if (windows[i] <= customer.arriveTime)
                return i;
        }
        return -1;
    }
}

class Customer {
    int arriveTime;
    int needTime;

    public Customer(int arriveTime, int needTime) {
        super();
        this.arriveTime = arriveTime;
        this.needTime = needTime * 60;
    }

}

	

 9942 个样本的时候过不去？？？？  样本只通过80% 后来发现是有一个地方少加了一个1
附 对数器 版本  调试大杀器，毕竟那么多人已经得到了答案
因为检查代码的时候总觉得没有问题可是牛客对于9000多个样本数据 也无法完全看到
还是对数器靠谱 
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>

using namespace std;

int nCus, kWin;


#define STARTTIME 8*60*60
#define CLOSETIME 17*60*60
struct cus
{
    int comTim;
    int processSecond;
    int waitTime = 0;
};

int kWindows[101] = { 0 };
vector<struct cus> cusV;

bool Cmp(struct cus & a, struct cus &b)
{
    return a.comTim < b.comTim;
}

int CalTime(string t1)
{
    int hour, minutes, seconds;
    hour = minutes = seconds = 0;
    sscanf(t1.c_str(), "%d:%d:%d", &hour, &minutes, &seconds);
    return hour * 60 * 60 + minutes * 60 + seconds;
}


double CalWaitTime(vector<struct cus> & v)
{
    // 先初始化最开始的人开始在窗口上排成一排  8:00 以及 8:00 以前来到的人
    memset(kWindows, 0, sizeof(kWindows));
    int customer = 0;
    // 然后在离结束之前一直在处理
    for (int i = STARTTIME; customer < v.size(); i++)
    {
        for (int j = 0; j < kWin; j++)
        {
            if (kWindows[j] != 0)
            {// 有人正在处理
                kWindows[j]--;
                // 如果处理完了 看队列中数据是否还有
                if (kWindows[j] == 0)
                {
                    if (customer < v.size() && v[customer].comTim <= i)
                    {
                        v[customer].waitTime = i - v[customer].comTim + 1;// 刚开始一直没找到这里少加了一个1s
                        kWindows[j] = v[customer++].processSecond;
                    }
                }
            }
            else// 如果本来就没人排队 看下一个客户来临的时间是否到达，如果达到那么就开始处理
            {
                if (customer < v.size()&&v[customer].comTim <= i)
                {
                    v[customer].waitTime = i - v[customer].comTim;
                    kWindows[j] = v[customer].processSecond - 1;
                    customer++;
                }
            }
        }
    }
    // 开始计算 customer 个 客户的等待时间
    long long sum = 0;
    for (int i = 0; i < customer; i++)
    {
        sum += v[i].waitTime;
    }
    if (customer)
    {
        return sum*1.0 / (double)(60.0 * customer);
    }
    else
    {
        return 0.0;
    }
     
}

int main()
{
    //ifstream cin("test2.txt");
    while (cin >> nCus >> kWin)
    {
        cusV.clear();
        //cusV.resize(nCus);
        string comTim;
        int processSecond;
        int comTime;
        for (int i = 0; i < nCus; i++) // 从第一个开始算
        {
            cin >> comTim >> processSecond;
            if (CalTime(comTim) > CLOSETIME)
            {
                continue;
            }
            else
            {
                struct cus *p = new struct cus;
                p->comTim = CalTime(comTim);
                if (processSecond > 60) processSecond = 60;
                p->processSecond = processSecond * 60;
                cusV.push_back(*p);
            }
        }
        
        sort(cusV.begin(), cusV.end(), Cmp);
        printf("%.1lf\n", CalWaitTime(cusV));
        // 计算等待的总共分钟数
    }
    system("pause");
}



#include <iostream>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <windows.h>
#include <string>



#include <string.h>
#include <algorithm>
#include <vector>
using namespace std;


int random(int a, int b) // 生成 [a,b] 之间的随机数 
{
    return rand()%(b-a+1)+a;
}

string AddZero(int x)
{
    string rlt;
    if(x <= 9)
    {
        rlt = "0";
        rlt += x + '0';
    }
    else
    {
        rlt = x / 10 + '0';
        rlt += x % 10 + '0'; 
    }
    return rlt;
}

bool GenData(void) // 生成器 
{
        ofstream ofile;
        ofile.open("c:\\Users\\leon\\OneDrive\\Documents\\Test\\DEV_C++\\Proj10_9\\case.txt", ios::out ); //| ios::app | ios::trunc 为输出(写)而打开文件 所有输出附加在文件末尾  
        if(!ofile.is_open())
        {
            cout << "ofile文件打开失败" << endl; 
            return 0;
        }
        int N = random(1, 10000);
        int K = random(1, 100);
        ofile << N << " " << K << endl;
        int hour,minute,second,process;
        for(int i=0; i<N; i++)
        {
            hour = random(0, 23);
            minute = random(0, 59);
            second = random(0, 59);
            process = random(0, 60);
            ofile << AddZero(hour) << ":" << AddZero(minute) << ":" << AddZero(second) << " " << process << endl;
        }
                
        ofile.close();
        Sleep(10);
        return true;
}
int result1,result2;
// --------------------------------------------------------------------------------------------- 
int nCus, kWin;

#define STARTTIME 8*60*60
#define CLOSETIME 17*60*60
struct cus
{
    int comTim;
    int processSecond;
    int waitTime = 0;
};

int kWindows[101] = { 0 };
vector<struct cus> cusV;

bool Cmp(struct cus & a, struct cus &b)
{
    return a.comTim < b.comTim;
}

int CalTime(string t1)
{
    int hour, minutes, seconds;
    hour = minutes = seconds = 0;
    sscanf(t1.c_str(), "%d:%d:%d", &hour, &minutes, &seconds);
    return hour * 60 * 60 + minutes * 60 + seconds;
}


double CalWaitTime(vector<struct cus> & v)
{
    // 先初始化最开始的人开始在窗口上排成一排  8:00 以及 8:00 以前来到的人
    memset(kWindows, 0, sizeof(kWindows));
    int customer = 0;
    // 然后在离结束之前一直在处理
    for (int i = STARTTIME; customer < v.size(); i++)
    {
        for (int j = 0; j < kWin; j++)
        {
            if (kWindows[j] != 0)
            {// 有人正在处理
                kWindows[j]--;
                // 如果处理完了 看队列中数据是否还有
                if (kWindows[j] == 0)
                {
                    if (customer < v.size() && v[customer].comTim <= i)
                    {
                        v[customer].waitTime = i - v[customer].comTim+1;
                        kWindows[j] = v[customer++].processSecond;
                    }
                }
            }
            else// 如果本来就没人排队 看下一个客户来临的时间是否到达，如果达到那么就开始处理
            {
                if (customer < v.size() && v[customer].comTim <= i)
                {
                    v[customer].waitTime = i - v[customer].comTim;
                    kWindows[j] = v[customer].processSecond - 1;
                    customer++;
                }
            }
        }
    }
    // 开始计算 customer 个 客户的等待时间
    long long sum = 0;
    for (int i = 0; i < customer; i++)
    {
        sum += v[i].waitTime;
    }
    cout << "sum" << sum << endl;
    result1 = sum; 
    if (customer)
    {
        return sum*1.0 / (double)(60.0 * customer);
    }
    else
    {
        return 0.0;
    }
     
}

double EXE1(void)
{
    ifstream cin("case.txt");
    while (cin >> nCus >> kWin)
    {
        cusV.clear();
        //cusV.resize(nCus);
        string comTim;
        int processSecond;
        int comTime;
        for (int i = 0; i < nCus; i++) // 从第一个开始算
        {
            cin >> comTim >> processSecond;
            if (CalTime(comTim) > CLOSETIME)
            {
                continue;
            }
            else
            {
                struct cus *p = new struct cus;
                p->comTim = CalTime(comTim);
                if (processSecond > 60) processSecond = 60;
                p->processSecond = processSecond * 60;
                cusV.push_back(*p);
            }
        }
        
        sort(cusV.begin(), cusV.end(), Cmp);
        printf("%.1lf\n", CalWaitTime(cusV));
    }
    cin.close();
    Sleep(10); 
    return result1;
}

double EXE2(void)
{
    int N, K;
    int P[10000];
    //ifstream cin("case.txt");
    freopen("case.txt","r",stdin);
    scanf("%d %d", &N, &K);
    for (int i = 0; i < N; i++)
    {
        int h, m, s, p;
        scanf("%d:%d:%d %d", &h, &m, &s, &p);
        cout << h << " " << m << endl;
        if (p > 60)
            p = 60;
        P[i] = ((h * 3600 + m * 60 + s) << 12) + p * 60;
    }
    sort(P, P + N);
    int W[K];
    for (int i = 0; i < K; i++)
    {
        W[i] = 8 * 3600;
    }
    int sum, count;
    sum = 0;
    for (count = 0; count < N; count++)
    {
        if ((P[count] >> 12) > 17 * 3600)
            break;
        int min = 0;
        for (int i = 1; i < K; i++)
        {
            if (W[min] > W[i])
                min = i;
        }
        int wait = W[min] - (P[count] >> 12);
        if (wait >= 0)
        {
            sum += wait;
            W[min] += (P[count] & 0xFFF);
        }
        else
        {
            W[min] = (P[count] >> 12) + (P[count] & 0xFFF);
        }
    }
    result2 = sum;
    if (count != 0)
    {
        printf("%.1f\n", sum / 60.0 / count);
        cout << "sum" << sum << endl;
    }
    else
    {
        printf("0.01\n");
    }
    //cin.close();
    Sleep(10); 
    return result2;
}
int main()
{
    for(int i=0; i<100000; i++) // 比较 100000 次 
    {
        if(GenData())
        {
            cout << "生成器生成数据成功" << endl;
        }
        // 执行两个程序
        cout << endl <<"开始执行1" << endl;
        EXE1();
        cout << endl << "执行结束1" << endl << "开始执行2" << endl;
        EXE2(); 
        cout << endl << "执行结束2" << endl;
        // 开始比较数据 
        if(result1 != result2)
        {
            cout << "数据不相等 " <<  result1 << " " << result2 << endl;
            break; 
        }
        cout<< "第 " << i  << " 次执行" << endl; 
    }

    system("pause");
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#pragma warning(disable:4996);
struct cus {
    int stamp, waiting, occu; //到来的时间，等待服务的时间，占用窗口时长
};

vector <cus> q;

int n, k;
int win[101]; //记录窗口时间
double total=0;
bool cmp(cus a, cus b) { //按照先到的顺序排序
    return a.stamp < b.stamp;
}

int main() {
#if ONLINE_JUDGE
#else
    freopen("input.txt", "r", stdin);
#endif
    cin >> n >> k;
    int h, m, s, o, cnt = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d:%d:%d %d", &h, &m, &s, &o);
        if (h * 3600 + m * 60 + s < 17 * 3600 + 1) { //符合条件的记录算进去
            cus c;
            c.stamp = h * 3600 + m * 60 + s;
            c.occu = o * 60;
            q.push_back(c);
        }
    }
    for (int i = 0; i < k; i++) { //窗口时间初始化
        win[i] = 8 * 3600;
    }
    sort(q.begin(), q.end(), cmp);
    for (int i = 0; i < q.size();i++) {
        cus c = q[i];
        int mintim = *min_element(win, win + k); //获取最早结束的窗口时间
        //mintim = mintim < 17 * 3600 ? mintim : 17 * 3600; //结束时间要小于窗口关闭时间
        int tmp = c.stamp < mintim ? (mintim - c.stamp) : 0; //获得用户需要等待的时间
        mintim=mintim>c.stamp?mintim:c.stamp;
                *min_element(win, win + k) = mintim + c.occu;
        c.waiting = tmp;
        total += tmp;
    }
    double res = total / 60 / q.size();
    printf("%.1lf", res);
}

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
struct node{
	int hh,mm,ss,op,toally;
	node(int hh,int mm,int ss,int op,int toally):hh(hh),mm(mm),ss(ss),op(op),toally(toally){}
};
int n,k,hh,mm,ss,op,opentime=8*3600,closetime=17*3600,cnt=0,ans=0;
bool cmp(node a,node b){return a.toally<b.toally;}
int main(){
	scanf("%d%d", &n, &k);
	vector<node> open;
	vector<int> windows(k,opentime);
	for(int i=0;i<n;i++){
		scanf("%d:%d:%d %d",&hh,&mm,&ss, &op);
		open.push_back(node(hh,mm,ss,op*60,hh*3600+mm*60+ss));
	}
	sort(open.begin(),open.end(),cmp);
	for(int i=0;i<n;i++){
		int Max=0x3fffffff,flag;
		for(int j=0;j<k;j++)
			if(windows[j]<Max){
				Max=windows[j];
				flag=j;
			}
		if(open[i].toally<=closetime){
			cnt++;//有效人数+1
			open[i].toally<windows[flag]? ans+=(windows[flag]-open[i].toally):windows[flag]=open[i].toally;
			open[i].op>3600 ? windows[flag]+=3600 : windows[flag]+=open[i].op;
		}
	}
    printf("%.1f",ans*1.0/(cnt*60));
	return 0;
}

PAT上就差一个点过不了，实在看不出问题在哪，求大家帮忙看看。 #include <iostream> #include <cstdio> #include <algorithm> using namespace std; const int maxn = 10010; const int maxk = 101; struct person{//个人信息 int hh,mm,ss;//到达时间 int on_time, off_time;//达到时间，离开时间(相对时间) int waiting_time = 0; int p;//服务时常（<=60） }per[maxn]; int N, K; int windows[maxk];//每个窗口的服务结束时间 int find_window(){//选择窗口 int MIN = (17 - 8) * 60*60 + 10, u = -1; for (int i = 0; i < K;++i){ if(windows[i]<MIN){
MIN = windows[i];
u = i;
}
} return u;
} double simulate(int count){//进行排队模拟 for (int i = 0; i < 3;++i){
per[i].waiting_time += 0; //开门后直接开始，不需额外等待 per[i].off_time = per[i].on_time + per[i].p;
windows[i] = per[i].off_time;
} for (int i = 3; i < count;++i){ int w = find_window();//选泽窗口 if(per[i].on_time>windows[w]){ //来的时候窗口有空位 per[i].waiting_time = 0;//不需要等待 per[i].off_time = per[i].on_time + per[i].p;
windows[w] = per[i].off_time;
} else{
per[i].waiting_time = windows[w]-per[i].on_time;
per[i].off_time = windows[w] + per[i].p;
windows[w] = per[i].off_time;
}
} int sum = 0; for(int i = 0; i < count;++i){
sum += per[i].waiting_time;
} double ave; return ave = sum / count/60.0000;
} bool cmp(person a,person b){ if(a.hh!=b.hh){ return a.hh < b.hh;
}else{ if(a.mm!=b.mm){ return a.mm < b.mm;
}else{ return a.ss < b.ss;
}
}
} int main(){
cin >> N >> K; if(N==0){
printf("0.0"); return 0;
} int count = N; for (int i = 0; i < N;++i){
scanf("%d:%d:%d %d", &per[i].hh, &per[i].mm, &per[i].ss, &per[i].p);
per[i].p *= 60;//变成秒 per[i].on_time = (per[i].hh-8)*3600 + per[i].mm * 60 + per[i].ss;
}
sort(per,per+N,cmp); for(int i = 0; i < N;++i){ if(per[i].hh<8){
per[i].on_time = 0;//8点前来的当作8点来 per[i].waiting_time=(8-per[i].hh) * 3600 - per[i].mm * 60 - per[i].ss; //提前来的人等待时间特殊处理 } else if(per[i].on_time>(17-8)*3600)
count--;//将晚来的直接舍掉 } double ave=simulate(count);
printf("%.1f", ave); return 0;
}

感觉和1016差不多, 就模拟一下几个队列, 有空位立即插入并计算等待时间, 没空位计算最早处理完的用户的离去时间，并更新为当前时间等等。

#include <iostream>
#include <queue>
#include <vector>
#include <cstdio>
#include <iomanip>
#include <algorithm>
using namespace std;

struct record
{
    int arrive_time;
    int process_time;
};
vector<queue<int>> my_ques;
vector<record> arrive_times;
vector<int> finish_times;

bool cmp(const record &a, const record &b) {
    return a.arrive_time < b.arrive_time;
}

int main()
{
    int customer_n, window_n;
    cin >> customer_n >> window_n;
    my_ques.resize(window_n);
    finish_times.resize(customer_n);
    int hour, minute, second, process_t;
    for (int i = 0; i < customer_n; i++) {
        scanf("%d:%d:%d", &hour, &minute, &second);
        cin >> process_t;
        record temp;
        temp.arrive_time = hour * 60 * 60 + minute * 60 + second;
        temp.process_time = process_t;
        arrive_times.push_back(temp);
    }
    sort(arrive_times.begin(), arrive_times.end(), cmp);
    int index = 0;
    int cur_serve = 0;
    int cur_time = 8 * 60 * 60;
    int total_waiting_time = 0;
    int toatl_served_cus = 0;
    while (index < arrive_times.size()) {
        if (cur_serve < window_n) {
            for (int i = 0; i < my_ques.size(); i++) {
                if (my_ques[i].empty()) {
                    my_ques[i].push(index);
                    break;
                }
            }
            if ((cur_time - arrive_times[index].arrive_time) > 0) {
                finish_times[index] = cur_time + arrive_times[index].process_time * 60;
                total_waiting_time += cur_time - arrive_times[index].arrive_time;
            }
            else {
                finish_times[index] = arrive_times[index].arrive_time + arrive_times[index].process_time * 60;
            }
            cur_serve++;
            index++;
            toatl_served_cus++;
        }
        else {
            cur_time = finish_times[my_ques[0].front()];
            for (int i = 0; i < my_ques.size(); i++) {
                if (finish_times[my_ques[i].front()] < cur_time) {
                    cur_time = finish_times[my_ques[i].front()];
                }
            }
            for (int i = 0; i < my_ques.size(); i++) {
                if (finish_times[my_ques[i].front()] == cur_time) {
                    my_ques[i].pop();
                    cur_serve--;
                }
            }
        }
        if (arrive_times[index].arrive_time > 17 * 60 * 60)
            break;
    }
    cout.setf(ios::fixed);
    cout << setprecision(1) << total_waiting_time * 1.0 / (60 * toatl_served_cus) << endl;

    return 0;
}

// 银行排队问题
// 模拟队列
// 两种情况
//        1. 如果有空闲窗口，直接处理客户业务;
//        2. 否则，等待最先处理完毕的窗口。
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

#ifdef ONLINE_JUDGE
#else
#include <fstream>
#endif

using namespace std;

struct Time
{
    int hour;
    int min;
    int sec;
};

struct Customer
{
    int arrival;
    int waittime;
};

int tos(const Time a)
{
    return (a.hour * 3600 + a.min * 60 + a.sec);
}

bool cmp(const Customer & a, const Customer & b)
{
    return a.arrival < b.arrival;
}

int main()
{
#ifdef ONLINE_JUDGE
#else
    ifstream cin("case.txt");
#endif // ONLINE_JUDGE

    int n, w;
    cin >> n >> w;

    // input customers' time arived
    vector<Customer>customer;
    Customer cus;
    Time time;
    char c;
    const int noserver = 17 * 3600;
    for (int i = 0;i < n;++i)
    {
        cin >> time.hour >> c >> time.min >> c >> time.sec >> cus.waittime;
        // 筛选数据
        cus.arrival = tos(time);
        cus.waittime *= 60;
        if (tos(time) < noserver)
        {
            customer.push_back(cus);
        }
    }

    sort(customer.begin(), customer.end(), cmp);
    
    //窗口时间线
    vector<int>windows;
    const int starttime = 8 * 3600;
    for (int i = 0;i < w;++i)
    {
        windows.push_back(starttime);
    }

    // 处理逻辑
    double sum = 0;
    n = customer.size();
    for (int i = 0;i < n;++i)
    {
        int min = 10000001;
        int index = 0;
        int j = 0;
        for (;j < w;++j)
        {
            if (customer[i].arrival >= windows[j])
            {
                windows[j] = customer[i].arrival + customer[i].waittime;
                break;
            }
            else
            {
                if (windows[j] < min)
                {
                    min = windows[j];
                    index = j;
                }
            }
        }
        if (j == w)
        {
            sum += min - customer[i].arrival;
            windows[index] += customer[i].waittime;
        }
    }
    
    // 秒数转分钟
    sum = (sum * 1.0 / 60 ) / n;
    printf("%.1lf\n", sum);
    getchar();
    return 0;
}

import Queue

class Customer:
    def __init__(self, arrivingTime, processingTime, idx):
        self.arrivingTime = arrivingTime
        self.processingTime = processingTime
        self.idx = idx
        self.waitingTime = 0

class TimeUnit:
    def __init__(self, time, isCustomer, idx=0):
        self.time = time
        self.isCustomer = isCustomer
        self.idx = idx
    def __cmp__(self, other):
        return cmp(self.time, other.time)

N, K = map(int, raw_input().strip().split())
customers = []
timeLine = Queue.PriorityQueue()
startTime = 8*3600; endTime = 17*3600
idx = 0
for i in range(N):
    time, processingTime = raw_input().strip().split()
    time = map(int, time.split(':'))
    arrivingTime = time[0]*3600 + time[1]*60 + time[2]
    if arrivingTime <= endTime:
        processingTime = int(processingTime)*60
        customers.append(Customer(arrivingTime, processingTime, idx))
        timeLine.put(TimeUnit(arrivingTime, True, idx))
        idx = idx + 1
waitingList = []
i = 0; k = 0
N = len(customers)
while k<K:
    timeLine.put(TimeUnit(startTime, False))
    k = k + 1
while i<N:
    item = timeLine.get()
    if item.isCustomer:
        if k<K:
            k = k + 1
            customers[item.idx].waitingTime = item.time - customers[item.idx].arrivingTime
            i = i + 1
            timeLine.put(TimeUnit(item.time+customers[item.idx].processingTime, False))
        else:
            waitingList.append(item.idx)
    else:
        if waitingList:
            idx = waitingList.pop(0)
            customers[idx].waitingTime = item.time - customers[idx].arrivingTime
            i = i + 1
            timeLine.put(TimeUnit(item.time+customers[idx].processingTime, False))
        else:
            k = k - 1
sumTime = 0
for item in customers:
    sumTime = sumTime + item.waitingTime
print '%.1f' % (sumTime/(N*60.0))