package kursatch;

import java.util.Random;

/**

* Регистрация на рейс в аэропорту начинается за 2 часа до вылета.

* Регистрация завершается за 30 минут до вылета. На самолёт помещается

* от 100 до 300 человек (распределение равномерное). На процедуру регистрации

* пассажир тратит время, распределённое по нормальному закону с матожиданием 5

мин.

* и дисперсией 3 мин. Определить минимальное количество стоек регистрации

необходимое для того,

* чтобы все рейсы улетали вовремя. Определить среднее время нахождения пассажиров
в очереди при

* минимальной и максимальной загрузке самолёта, среднюю загрузку стоек

регистрации при минимальной

* и максимальной загрузке самолёта.

*/

public class Kursatch {

private final static int MAX_LOAD = 300; // максимальная загрузка рейса

private final static int MIN_LOAD = 100; // минимальная загрузка рейса

private final static int REGISTRATION_TIME = 90; // продолжительность регистрации на

рейс (в минутах)

private final static double MEAN = 5.0; // математическое ожидаение

private final static double DISPERSION = 3.0; // дисперсия

private final static long RAND_SEED = 1235; // постоянное зерно рандома для
одинаковых результатов при каждом запуске программы

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

// TODO code application logic here

int flightLoad = generateUniform(MIN_LOAD, MAX_LOAD); // получаем загрузку рейса

System.out.println("*************************************************************
");

System.out.println("* Рейс со случайной загрузкой по равномерному распределению

*");

System.out.println("*************************************************************
");

simulate(19, flightLoad);

System.out.println();

System.out.println("*************************************************************
");

System.out.println("* Рейс c максимальной загрузкой *"); //

недостаточно стоек

System.out.println("*************************************************************
");

simulate(18, MAX_LOAD);

System.out.println();

System.out.println("*************************************************************
");

System.out.println("* Рейс c максимальной загрузкой *"); //

оптимальное число стоек

System.out.println("*************************************************************
");

simulate(19, MAX_LOAD);

System.out.println();
System.out.println("*************************************************************
");

System.out.println("* Рейс c максимальной загрузкой *"); // слишком

много стоек

System.out.println("*************************************************************
");

simulate(28, MAX_LOAD);

/**

* Симуляция регистрации на один рейс

* @param reseptionCount количество стоек регистрации

* @param flightLoad загрузка рейса

*/

private static void simulate(int reseptionCount, int flightLoad) {

double[] linesWaitingTime = new double[reseptionCount]; // сумма времени ожидания

для каждой стойки

double[] linesPassengerCount = new double[reseptionCount]; // число прошедших

регистрацию пассажиров для каждой стойки

boolean[] reseptionClosed = new boolean[reseptionCount]; // для каждой стойки

показатель, что на стойка больше не может принять пассажиров за отведённое время

//цикл по пассажирам

int i = 0;

while (i < flightLoad) {

// цикл по стойкам регистрации

for (int c = 0; c < reseptionCount; c++) {

// пропускаем, если стойка больше не может принимать пассажиров

if (reseptionClosed[c]) {

continue;

// получаем время ожидание для следующего пассажира

 double passengerWaitTime = generateNormal(MEAN, Math.sqrt(DISPERSION));

// получаем общую сумму времени ожидания по стойке регистрации

double currentLineTime = linesWaitingTime[c];

// если регистрация нового пассажира укладывается в общее время регистрации

на рейс

if (currentLineTime + passengerWaitTime < REGISTRATION_TIME) {

// записываем пассажира и его время в счёт это стойки регистрации

linesWaitingTime[c] = currentLineTime + passengerWaitTime;

linesPassengerCount[c] += 1;

i++;

} else {

// иначе закрываем стойку

reseptionClosed[c] = true;

// проверяем, закрыты ли все стойки

boolean allReseptionClosed = true;

for (int c = 0; c < reseptionCount; c++) {

allReseptionClosed = allReseptionClosed && reseptionClosed[c];

// если да, выводим число пассажиров, не успевших пройти регистрацию, и

завершаем моделирование

if (allReseptionClosed) {

System.out.println((flightLoad - i) + " пассажиров не успели на рейс.");

break;

// суммируем чило прошедших регистрацию пассажиров и время очереди по всем

стойкам

double waitingSum = 0;

int passengerCountSum = 0;

for (int c = 0; c < reseptionCount; c++) {

 waitingSum += linesWaitingTime[c];

passengerCountSum += linesPassengerCount[c];

// выводим результат моделирования

System.out.println("Загрузка рейса: " + flightLoad + " пассажиров");

System.out.println("Число стоек регистрации : " + reseptionCount);

System.out.println("Среднее время ожидания в очереди: " + (waitingSum /

reseptionCount) + " минут");

System.out.println("Средняя загрузка стойки регистрации: " + (passengerCountSum /

reseptionCount) + " человек");

/**

* Распределение по нормальному закону

* @param mean мат. ожидание

* @param standardDeviation Среднеквадратическое отклонение = квадратный корень

дисперсии

* @return случайная величина, распределённая по нормальному закону

*/

private static double generateNormal(double mean, double standardDeviation){

Random random = new Random(RAND_SEED); // используем постоянное зерно

return random.nextGaussian() * standardDeviation + mean;

/**

* Равномерное распределение

* @param min минимальное значение

* @param max максимальное значение

* @return случайная величина, распределённая равномерно

*/

private static int generateUniform(int min, int max) {

Random random = new Random(); // используем случайное зерно

 return random.nextInt((max - min) + 1) + min;