Statystyka · Biznes

Overbooking – ile rezerwacji przyjąć ponad liczbę pokoi

Fikcyjny pensjonat w górach z 24 pokojami i rezerwacje z trzech sezonów. Rozkład dwumianowy przyjazdów, koszt pustego pokoju wobec kosztu odmowy, optymalna liczba rezerwacji, bootstrap nocy, analiza wrażliwości, grupy w rozkładzie beta-dwumianowym i pułapka definicji nieobecności – sześć rysunków z kodem R i zdania do pracy.

Strona główna / Blog / Overbooking
W skrócie: Liczbę rezerwacji ponad pojemność wybiera się z rozkładu liczby przyjazdów i dwóch kosztów: pustego pokoju i odesłania gościa. W przykładzie pensjonatu z 24 pokojami (p przyjazdu w sezonie .928, pusty pokój 350 zł, odmowa 750 zł) najtańsze jest 25 rezerwacji na noc: odmowa w 15.5% nocy, a oszczędność 23 177 zł na sezon. Niepewność p z bootstrapu nie zmienia decyzji, ale koszt odmowy tak – od 1750 zł overbooking się nie opłaca. Grupy podnoszą ryzyko, a liczenie wszystkich odwołań jako nieobecności prowadzi do odmów w 94.6% nocy.

Przykład: pensjonat w górach i 24 pokoje

Fikcyjny pensjonat w górach ma 24 pokoje. W sezonie (ferie, święta, lato – 150 nocy w roku) prawie każda noc jest wyprzedana, a mimo to część pokoi stoi pusta: ktoś odwołał rezerwację w ostatniej chwili albo nie przyjechał. Właściciel pyta: ile rezerwacji przyjmować na noc, skoro nie wszyscy przyjeżdżają? To pytanie o overbooking – sprzedaż ponad pojemność, którą linie lotnicze od dziesięcioleci opierają na modelach statystycznych (Rothstein, 1985).

Dane obejmują trzy sezony (lata): 1080 nocy i 21 844 rezerwacje. Limit ustalamy 3 dni przed przyjazdem – później zwolnionego pokoju nie da się sprzedać. W księgach było wtedy 18 757 rezerwacji: bezzwrotnych, elastycznych (z darmowym odwołaniem) i grupowych (4–8 pokoi). Każda kończy się przyjazdem, odwołaniem na mniej niż 3 dni przed przyjazdem albo nieprzyjazdem bez uprzedzenia (no-show). Dla prostoty rezerwacja to jeden pokój na noc przyjazdu; model z przyjazdami rozłożonymi w czasie opisali Bitran i Gilbert (1996).

W sezonie 92.7% nocy było wyprzedanych (średnio 23.79 rezerwacji i 22.04 przyjazdów), poza sezonem – 0.3%. Overbooking ma więc sens w sezonie.

Dane są fikcyjne i wiemy, co w nich ukryliśmy. Prawdziwe p przyjazdu to w sezonie 0.97 (bezzwrotne) i 0.90 (elastyczne), poza sezonem 0.95 i 0.82; noce różnią się wspólnym czynnikiem (pogoda, drogi), a goście z jednej grupy decydują podobnie. Parametry ustawiliśmy ręcznie (lista przy kodzie), ziarna 752 nie zmienialiśmy. Dane: overbooking-pensjonat-rezerwacje.csv.

Rysunek 1: karta „24 pokoje, ile rezerwacji?”

Grafika: 24 niebieskie kwadraty pokoi w czterech rzędach i jeden pomarańczowy kwadrat z przerywaną ramką oznaczony +1 – rezerwacja ponad pojemność. Obok pięć kart: p przyjazdu .928 [.923, .933] w sezonie i .885 poza sezonem; pusty pokój 350 zł, odmowa 750 zł; N* = 25, zysk 23 177 zł na sezon; odmowa w 15.5% nocy, puste średnio 0.95 pokoju zamiast 1.73; grupa 8 pokoi – odmowa w 18.5% zamiast 11.8% nocy, przy koszcie odmowy powyżej 1725 zł N = 24
Rysunek 1. Decyzja o overbookingu w pensjonacie z 24 pokojami: odsetek przyjazdów, koszty pomyłek, optymalna liczba rezerwacji i ryzyko odmowy. Grafika: R, pakiet ggplot2 (dane fikcyjne, set.seed(752)).

Co widać. Przy 24 rezerwacjach średnio 1.73 pokoju stoi pusty. Jedna rezerwacja ponad pojemność zmniejsza tę liczbę do 0.95, ale w 15.5% nocy komuś zabraknie pokoju. Przy przyjętych kosztach daje to 23 177 zł na sezon.

Jak może zmylić. Karta podaje jedną liczbę, a odpowiedź zależy od kosztu odmowy (rysunek 4) i od grup (rysunek 5).

Podpis do pracy:

Rysunek 1. Schemat decyzji o liczbie przyjmowanych rezerwacji w obiekcie z 24 pokojami w sezonie. Uwaga. p – odsetek rezerwacji aktywnych 3 dni przed przyjazdem, które zakończyły się przyjazdem (95% przedział Wilsona); N* – liczba rezerwacji minimalizująca oczekiwany koszt pustych pokoi (350 zł) i odmów (750 zł). Dane fikcyjne.

Ile osób przyjeżdża? Odsetek przyjazdów z przedziałem

Podstawą jest odsetek przyjazdów p wśród rezerwacji obecnych w księgach 3 dni przed przyjazdem, z przedziałem ufności dla proporcji Wilsona, który zalecają Brown i in. (2001).

Odsetek przyjazdów według okresu i rodzaju rezerwacji
Rodzaj rezerwacjiSezon: nSezon: p [95% CI]Poza sezonem: nPoza sezonem: p [95% CI]
Bezzwrotna4601.964 [.958, .969]3429.957 [.950, .963]
Elastyczna5480.898 [.890, .906]4076.824 [.812, .836]
Grupowa624.904 [.878, .925]547.890 [.861, .914]
Indywidualne razem10 081.928 [.923, .933]7505.885 [.877, .892]
Tabela 1. Odsetek rezerwacji aktywnych 3 dni przed przyjazdem, które zakończyły się przyjazdem, według okresu i rodzaju rezerwacji. Uwaga. CI – 95% przedział ufności Wilsona; nieobecność = odwołanie na mniej niż 3 dni przed przyjazdem albo nieprzyjazd bez uprzedzenia. Dane fikcyjne z trzech sezonów.

Rezerwacje bezzwrotne kończą się przyjazdem częściej niż elastyczne, a w sezonie goście przyjeżdżają częściej niż poza nim (o 4.34 pp). Ryzyko dla pojedynczej rezerwacji można modelować jak we wpisie o nieodwołanych wizytach (no-show); tu decyzja dotyczy limitu na noc, więc wystarczy p dla grup rezerwacji.

Rysunek 2: ilu gości przyjedzie przy N rezerwacjach

Jeśli każda z N rezerwacji niezależnie kończy się przyjazdem z tym samym p, liczba przyjazdów S ma rozkład dwumianowy:

S ~ Bin(N, p),   P(S = s) = (N po s) · ps · (1 − p)N − s

Rozkład mówi, jak często przyjedzie 22, 23, 24 czy 25 osób. Bierzemy p = .928 (sezon, rezerwacje indywidualne).

Trzy wykresy słupkowe rozkładu dwumianowego liczby przyjazdów przy p = .928, z linią przerywaną za 24 pokojami. N = 24: wszystkie słupki niebieskie, średnio 22.27 przyjazdu. N = 25: pomarańczowy słupek przy 25 przyjazdach, 15.5%. N = 27: pomarańczowe słupki 25, 26 i 27 przyjazdów, razem 69.3%
Rysunek 2. Rozkład liczby przyjazdów przy 24, 25 i 27 przyjętych rezerwacjach na noc w sezonie (rozkład dwumianowy, p = .928). Pomarańczowe słupki – noce, w których gości jest więcej niż pokoi. Obliczenia: R, pakiet ggplot2.

Co widać. Przy 24 rezerwacjach przyjeżdża średnio 22.27 osoby, przy 25 – 23.20, a w 15.5% nocy przyjeżdżają wszyscy i jednego gościa trzeba odesłać. Przy 27 rezerwacjach odmowa zdarza się w 69.3% nocy.

Jak może zmylić. Model zakłada, że goście decydują niezależnie i z tym samym p. Mieszanka rodzajów rezerwacji, pogoda i grupy łamią to założenie (rysunki 4 i 5).

Podpis do pracy:

Rysunek 2. Rozkład liczby przyjazdów przy 24, 25 i 27 rezerwacjach na noc. Uwaga. Rozkład dwumianowy z p = .928 (odsetek przyjazdów rezerwacji indywidualnych w sezonie); linia przerywana – pojemność obiektu (24 pokoje).

Zdanie do Wyników:

Przy 25 przyjętych rezerwacjach na noc w sezonie oczekiwana liczba przyjazdów wynosi 23.20, a prawdopodobieństwo, że przyjedzie więcej gości niż 24, wynosi .155 (przy 27 rezerwacjach – .693).

Rysunek 3: koszt pustego pokoju czy koszt odmowy – optymalne N

Pusty pokój to utracona marża: 350 zł. Odmowa to nocleg w innym obiekcie z dojazdem (450 zł) i rekompensata (300 zł): 750 zł. Szukamy N, przy którym wartość oczekiwana kosztu jest najmniejsza:

E[koszt(N)] = 350 · E[pustych pokoi] + 750 · E[odesłanych gości]

Reguła na skróty: dokładaj rezerwację, dopóki szansa, że przyjedzie mniej niż 24 osoby, przekracza 750 / (750 + 350) = 0.682. Przy N = 24 wynosi ona 0.833, przy N = 25 – 0.545, więc N* = 25. To rachunek z modelu gazeciarza, tylko niepewny jest przyjazd, nie popyt.

Dwa panele. A: oczekiwany koszt na noc w sezonie według N od 24 do 30; koszt pustych pokoi maleje (604 zł przy 24), koszt odmów rośnie; suma: 604 zł przy 24, minimum 449 zł przy N* = 25, 589 zł przy 26, 992 zł przy 27. B: prawdopodobieństwo odmowy według N: w sezonie (p = .928) 15.5% przy 25, 43.3% przy 26, 69.3% przy 27; poza sezonem (p = .885) niżej, np. 18.2% przy 26
Rysunek 3. Oczekiwany koszt pustych pokoi i odmów na noc w sezonie (A) oraz prawdopodobieństwo, że gości będzie więcej niż pokoi, w sezonie i poza nim (B), według liczby przyjętych rezerwacji. Obliczenia: R, pakiety ggplot2 i patchwork.

Co widać. Bez overbookingu pensjonat traci na pustych pokojach średnio 604 zł na noc. Przy N = 25 łączny koszt spada do 449.4 zł – o 154.5 zł na noc i 23 177 zł na sezon. Poza sezonem p jest niższe i N* = 26, ale tylko 0.3% nocy poza sezonem ma co najmniej 24 rezerwacje, więc limit prawie nie działa.

Jak może zmylić. Za dużo kosztuje więcej niż za mało: limit spoza sezonu (26) zostawiony na sezon daje odmowę w 43.3% nocy i koszt 588.8 zł. Liczy się też rodzaj rezerwacji: przy samych bezzwrotnych N* = 24, przy samych elastycznych N* = 26.

Podpis do pracy:

Rysunek 3. Oczekiwany koszt na noc w zależności od liczby przyjętych rezerwacji (A) i prawdopodobieństwo odmowy w sezonie i poza nim (B). Uwaga. Koszt pustego pokoju 350 zł, koszt odmowy 750 zł; liczba przyjazdów z rozkładu dwumianowego z p oszacowanym osobno dla każdego okresu.

Zdanie do Wyników:

Oczekiwany koszt pustych pokoi i odmów był najmniejszy przy 25 rezerwacjach na noc (449.4 zł wobec 604.0 zł bez overbookingu), co przy 150 nocach sezonu oznacza oszczędność 23 177 zł; prawdopodobieństwo odmowy wynosi wtedy .155.

Rysunek 4: niepewność p i koszt odmowy – analiza wrażliwości

p znamy tylko z próby. Jego niepewność szacujemy bootstrapem (Efron, 1979): 2000 razy losujemy ze zwracaniem całe noce sezonu (rezerwacje z jednej nocy łączy pogoda) i liczymy p oraz N*. Koszt odmowy – zwłaszcza zła opinia gościa – jest jeszcze mniej pewny, więc robimy analizę wrażliwości dla kosztu od 350 do 3500 zł.

Dwa panele. A: histogram 2000 wartości p z bootstrapu nocy, 95% z nich między .923 a .934, w całości w szarej strefie N* = 25; pomarańczowa strefa N* = 26 kończy się na .908, niebieska strefa N* = 24 zaczyna się od .953. B: optymalne N* według kosztu odmowy od 350 do 3500 zł dla dolnej granicy przedziału, p punktowego i górnej granicy; przy p punktowym N* = 26 do 400 zł, 25 od 425 do 1725 zł, 24 od 1750 zł; kropkowana linia przy 750 zł
Rysunek 4. Rozkład odsetka przyjazdów w sezonie z bootstrapu nocy (2000 powtórzeń) na tle wartości p, przy których zmienia się optymalna liczba rezerwacji (A), oraz optymalna liczba rezerwacji według kosztu odmowy (B). Obliczenia: R, pakiety ggplot2 i patchwork (set.seed(7521)).

Co widać. Przedział z bootstrapu nocy [.923, .934] jest prawie taki sam jak przedział Wilsona [.923, .933], a we wszystkich 2000 losowaniach N* = 25; zmieniłoby się dopiero przy p ≤ .908 albo p > .953. Więcej zależy od kosztu odmowy: N* = 25 dla kosztu od 425 do 1725 zł, a od 1750 zł (siatka co 25 zł) overbooking się nie opłaca. Przy 1500 zł zysk z sezonu spada do 5759 zł.

Jak może zmylić. Mała niepewność p wynika z 10 081 rezerwacji. Nowy obiekt albo pojedyncze noce (Sylwester) mają szersze przedziały. Analiza wrażliwości nie mówi, ile kosztuje odmowa – tylko, od jakiej kwoty zmienia się decyzja.

Podpis do pracy:

Rysunek 4. Niepewność odsetka przyjazdów (A) i wrażliwość optymalnej liczby rezerwacji na koszt odmowy (B). Uwaga. A: 2000 prób bootstrapowych losujących noce ze zwracaniem; strefy – zakresy p, dla których optymalne N wynosi 26, 25 i 24. B: koszt pustego pokoju 350 zł; linie dla p punktowego oraz granic 95% przedziału Wilsona.

Zdanie do Wyników:

Optymalna liczba rezerwacji (N = 25) nie zmieniła się w żadnej z 2000 prób bootstrapowych (95% CI dla p [.923, .934]); w analizie wrażliwości pozostawała równa 25 dla kosztu odmowy od 425 do 1725 zł, a przy wyższym koszcie overbooking przestawał się opłacać.

Rysunek 5: grupy odwołują razem – rozkład beta-dwumianowy

Gdy szkoła czy firma odwołuje wyjazd, znika kilka pokoi naraz. Opisuje to rozkład beta-dwumianowy (Williams, 1975): każda grupa ma własne p z rozkładu beta, a zależność mierzy korelacja ρ przyjazdów w grupie – odpowiednik korelacji wewnątrzklasowej. Parametry szacujemy metodą największej wiarygodności ze 198 grup (1171 pokoi).

Wykres liniowy prawdopodobieństwa odmowy w nocy z grupą 8 pokoi według N od 24 do 30. Model dwumianowy (grupa jak 8 osobnych rezerwacji, linia przerywana): 11.8% przy 25, 36.4% przy 26. Model beta-dwumianowy (grupa odwołuje razem, linia ciągła): 18.5% przy 25, 44.9% przy 26. Od N = 28 kolejność linii się odwraca. Grupa: średnie p = .898, korelacja ρ = .29
Rysunek 5. Prawdopodobieństwo odmowy w nocy w sezonie z jedną rezerwacją grupową na 8 pokoi, gdy grupę modelujemy jak 8 niezależnych rezerwacji (rozkład dwumianowy) i jak grupę z zależnymi przyjazdami (rozkład beta-dwumianowy). Obliczenia: R, pakiet ggplot2.

Co widać. ρ = .29 (95% CI [.21, .40]); test ilorazu wiarygodności odrzuca model dwumianowy (χ² = 110.45, p < .001). Wariancja liczby przyjazdów w grupie 8 pokoi jest trzy razy większa (2.25 wobec 0.74). Przy N = 25 odmowa grozi w 18.5% nocy zamiast 11.8%, a oczekiwany koszt rośnie z 495.0 do 568.6 zł. N* nadal wynosi 25, ale z mniejszym zapasem.

Jak może zmylić. Zależność grubi oba ogony: od N = 28 model beta-dwumianowy daje niższe ryzyko odmowy, bo częściej zdarza się też, że z grupy przyjedzie wyraźnie mniej osób. Licz ryzyko dla grup, które naprawdę przyjmujesz.

Podpis do pracy:

Rysunek 5. Prawdopodobieństwo, że liczba gości przekroczy 24 pokoje, w nocy z jedną rezerwacją grupową na 8 pokoi i (N − 8) rezerwacjami indywidualnymi. Uwaga. Linia przerywana – przyjazdy w grupie niezależne (rozkład dwumianowy); linia ciągła – rozkład beta-dwumianowy z μ = .898 i ρ = .29 oszacowanymi metodą największej wiarygodności ze 198 grup.

Zdanie do Wyników:

Przyjazdy w rezerwacjach grupowych były skorelowane (ρ = .29, 95% CI [.21, .40]; test ilorazu wiarygodności χ² = 110.45, p < .001). Przy 25 rezerwacjach, w tym grupie 8 pokoi, prawdopodobieństwo odmowy wynosiło .185 w modelu beta-dwumianowym wobec .118 przy założeniu niezależności.

Rysunek 6: kto „nie przyjechał”? Definicja zmienia wynik

System zna trzy „nieobecności”: no-show, odwołanie na mniej niż 3 dni przed przyjazdem i odwołanie wcześniejsze (pokój sprzedano ponownie). Do decyzji podejmowanej 3 dni przed przyjazdem pasuje jedna definicja: nieobecni to no-show plus późne odwołania, a mianownik – rezerwacje aktywne w dniu decyzji.

Dwa panele. A: szacowane p przy trzech definicjach: tylko no-show .971, no-show i odwołanie poniżej 3 dni (poprawnie) .928, wszystkie odwołania .788. B: odsetek nocy z odmową w sezonie przy limicie z danej definicji: N = 24 – 0%, 0 odmów na sezon; N = 25 – 15.5%, 23 odmowy; N = 29 – 94.6%, 440 odmów na sezon
Rysunek 6. Odsetek przyjazdów przy trzech definicjach nieobecności (A) i skutek limitu rezerwacji wyznaczonego z każdej z nich w sezonie (B). Obliczenia: R, pakiety ggplot2 i patchwork.

Co widać. Licząc tylko no-show, dostajemy p = .971 i N* = 24 – przepada 23 177 zł zysku. Licząc wszystkie odwołania (mianownik 11 871 rezerwacji), dostajemy p = .788 i N* = 29: odmowa w 94.6% nocy, 440 odesłanych gości w sezonie i strata 263 858 zł względem limitu 25.

Jak może zmylić. Wszystkie trzy liczby nazywa się „odsetkiem przyjazdów”. Definicja musi pasować do chwili decyzji – przy limicie ustalanym 7 dni przed przyjazdem byłaby inna.

Podpis do pracy:

Rysunek 6. Odsetek przyjazdów według definicji nieobecności (A) oraz odsetek nocy w sezonie z odmową przy limicie rezerwacji wyznaczonym z każdej definicji (B). Uwaga. Skutek limitu oceniono przy odsetku przyjazdów z definicji poprawnej (.928).

Zdanie do Metody:

Za nieobecność uznano odwołanie na mniej niż 3 dni przed przyjazdem lub nieprzyjazd bez uprzedzenia; rezerwacje odwołane wcześniej, których pokoje sprzedano ponownie, wyłączono z mianownika, ponieważ decyzję o limicie podejmowano 3 dni przed przyjazdem.

Co z tym zrobić w firmie

  • W sezonie przyjmuj 25 rezerwacji na noc, poza sezonem nic nie zmieniaj. Poza sezonem limit prawie nigdy nie jest osiągany.
  • Licz limit dla mieszanki rezerwacji. Więcej bezzwrotnych – mniejszy overbooking (przy samych bezzwrotnych żaden), więcej elastycznych – większy. Przeliczaj limit co sezon.
  • Noc z grupą traktuj ostrożniej. Grupa przyjeżdża często w komplecie (139 ze 198 grup), ale gdy rezygnuje, traci kilka pokoi naraz. Zamiast większego overbookingu rozważ zaliczkę i termin odwołania dla grup.
  • Ustal z góry, gdzie przeniesiesz gościa. Umowa z pobliskim obiektem obniża koszt odmowy, a od niego zależy decyzja. Rekompensata w gotówce podnosiła satysfakcję bardziej niż bon, ale żadna nadmiarowa rekompensata nie zwiększała chęci powrotu (Noone i Lee, 2011).
  • Zapisuj datę i rodzaj każdego odwołania. Prognozę obłożenia na tygodnie przed przyjazdem opisuje wpis o krzywej rezerwacji, a ryzyko finansowe sezonu – próg rentowności z symulacją Monte Carlo. Inne tematy prac z tej dziedziny: statystyka w pracy z turystyki i rekreacji.

Jak opisać w pracy

Opisz definicję nieobecności, okres danych, rozkład liczby przyjazdów, koszty (ze źródłem: cennik, umowa) i analizę wrażliwości. Ogólne zasady opisu są we wpisie statystyka w pracy z zarządzania i ekonomii.

Metoda. Analizowano 18 757 rezerwacji aktywnych 3 dni przed przyjazdem w obiekcie z 24 pokojami w trzech sezonach (1080 nocy). Nieobecność zdefiniowano jako odwołanie na mniej niż 3 dni przed przyjazdem lub nieprzyjazd bez uprzedzenia. Odsetki przyjazdów podano z 95% przedziałami Wilsona osobno dla sezonu i okresu poza sezonem oraz rodzaju rezerwacji. Liczbę przyjazdów przy N rezerwacjach modelowano rozkładem dwumianowym, a dla rezerwacji grupowych – rozkładem beta-dwumianowym, którego parametry oszacowano metodą największej wiarygodności. Optymalną liczbę rezerwacji wyznaczono przez minimalizację oczekiwanego kosztu pustych pokoi (350 zł) i odmów (750 zł). Niepewność odsetka przyjazdów oceniono bootstrapem nocy (2000 prób), a wpływ kosztu odmowy – analizą wrażliwości (350–3500 zł). Obliczenia wykonano w R 4.5.3.
Przykład reprodukowalny

Kod R: rozkład dwumianowy, koszt oczekiwany, bootstrap i rozkład beta-dwumianowy

Kod odtwarza wszystkie liczby z tekstu, tabelę 1 i sześć rysunków. Uruchom przepisy po kolei w jednej sesji R: przepis 1 tworzy dane, paletę kol, motyw motyw i funkcję minus(), a kolejne przepisy korzystają z obiektów z wcześniejszych. Przepisy 3–8 kończą się nazwą wykresu (p1–p6), co wyświetla go w oknie R; do zapisu w pliku SVG użyj ggsave() jak w komentarzu. Rysunki na tej stronie powstały z tych samych obiektów, którym podmieniono tylko motyw na motyw serwisu (krój i kolor czcionki, siatka) – dane, geometrie i skale są identyczne.

Losują przepisy 1 (set.seed(752)) i 5 (set.seed(7521)); ziarna ustalono raz i nie zmieniano. Ręcznie ustalono: 24 pokoje; 150 nocy sezonu i 210 nocy poza sezonem w roku przez 3 lata; średni popyt na noc 32 w sezonie i 13 poza nim (rozkład Poissona, przyjmowano najwyżej 24 rezerwacje); szansę rezerwacji grupowej na noc (0.25 i 0.15; 4–8 pokoi, tylko przy co najmniej 8 rezerwacjach); udział rezerwacji bezzwrotnych wśród indywidualnych (0.45); prawdziwe p przyjazdu (sezon: 0.97 bezzwrotne, 0.90 elastyczne; poza sezonem: 0.95 i 0.82); wspólny wpływ nocy na logit przyjazdu (odchylenie standardowe 0.25); grupy: średnie p 0.88 i korelacja 0.30; udział późnych odwołań wśród nieobecnych (0.30 bezzwrotne, 0.70 elastyczne, 0.80 grupy); liczbę wcześniejszych odwołań na rezerwację (0.02 bezzwrotne, 0.30 elastyczne); koszty (pusty pokój 350 zł, odmowa 750 zł) oraz liczbę prób bootstrapu (2000). Po pierwszym uruchomieniu nie zmieniano parametrów danych ani ziaren. Zmieniono tylko sposób pokazania wyników: na rysunku 2 zamiast N = 24, 27 i 30 pokazano N = 24, 25 i 27; na rysunku 3 oś skrócono do N = 30, a porównanie z p całorocznym (dało to samo N* = 25) zastąpiono limitem spoza sezonu stosowanym w sezonie; histogram na rysunku 4 uzupełniono o strefy N*; poprawiono układ karty i etykiet na rysunkach 5–6 oraz liczbę miejsc po przecinku przy ρ. Przepis 1 zapisuje dane do pliku CSV w katalogu roboczym. Cały kod liczy się kilka sekund.

1. Dane: noce, rezerwacje i ich los

Dane wejściowe: nic – dane losuje kod. Na początku – paleta Okabe–Ito kol, motyw motyw i funkcja minus() (znak − w etykietach).

Co odczytać: liczbę rezerwacji (wszystkich i aktywnych 3 dni przed przyjazdem) i nocy, statusy w sezonie i poza nim, udział rodzajów rezerwacji (%) oraz średnią liczbę rezerwacji i przyjazdów na noc i odsetek nocy wyprzedanych (%).

R
# Przepis 1. Fikcyjny pensjonat w górach (24 pokoje): rezerwacje i ich los z trzech sezonów
library(ggplot2)
options(width = 120)                                 # szerokie wydruki tabel

# Paleta Okabe–Ito (rozróżnialna także przy deuteranopii) i prosty motyw rysunków
kol <- c(niebieski = "#0072B2", pomarancz = "#D55E00", zielony = "#009E73", fiolet = "#CC79A7",
         zolty = "#E69F00", szary = "grey40")
motyw <- theme_minimal(base_size = 14) +
  theme(plot.title = element_text(face = "bold", colour = "#0f1d3a", size = rel(1.0)),
        plot.subtitle = element_text(colour = "grey30"), panel.grid.minor = element_blank(),
        panel.grid.major = element_line(colour = "grey88", linewidth = 0.4),
        strip.text = element_text(face = "bold", colour = "#0f1d3a"), legend.position = "bottom",
        plot.background = element_rect(fill = "white", colour = NA), plot.margin = margin(10, 14, 10, 10))
minus <- function(x) gsub("-(?=[0-9])", "−", x, perl = TRUE)   # znak minus (−) przed liczbami w etykietach

# Parametry ustalone ręcznie
POKOJE <- 24
noce <- c(sezon = 150, poza = 210)                   # noce w roku: sezon (ferie, święta, lato) i poza sezonem
popyt <- c(sezon = 32, poza = 13)                    # średnia liczba chętnych na noc (Poisson); przyjmowano najwyżej 24
p_grupa_noc <- c(sezon = 0.25, poza = 0.15)          # szansa, że w nocy jest rezerwacja grupowa (4–8 pokoi)
udzial_bezzwrotnych <- 0.45                          # wśród rezerwacji indywidualnych
p_przyjazd <- rbind(sezon = c(bezzwrotna = 0.97, elastyczna = 0.90),   # prawdziwe p przyjazdu
                    poza  = c(bezzwrotna = 0.95, elastyczna = 0.82))
sd_noc <- 0.25                                       # wspólny wpływ nocy (pogoda, drogi) na logit przyjazdu
grupa_mu <- 0.88; grupa_rho <- 0.30                  # grupa: średnie p przyjazdu i korelacja wewnątrz grupy (beta-dwumianowy)
p_odwolanie_ostatnia <- c(bezzwrotna = 0.30, elastyczna = 0.70, grupowa = 0.80)  # nieobecni: odwołanie < 3 dni vs no-show
wczesne <- c(bezzwrotna = 0.02, elastyczna = 0.30)   # odwołania > 3 dni przed przyjazdem (pokój sprzedany ponownie) na rezerwację

set.seed(752)
kalendarz <- do.call(rbind, lapply(1:3, function(r) data.frame(rok = r, okres = rep(names(noce), noce))))
kalendarz$noc <- seq_len(nrow(kalendarz))
rez <- vector("list", nrow(kalendarz))
for (i in seq_len(nrow(kalendarz))) {
  ok <- kalendarz$okres[i]
  w_ksiegach <- min(rpois(1, popyt[ok]), POKOJE)     # rezerwacje aktywne 3 dni przed przyjazdem
  m <- if (runif(1) < p_grupa_noc[ok] && w_ksiegach >= 8) sample(4:8, 1) else 0
  n_ind <- w_ksiegach - m
  typ <- c(rep("grupowa", m), ifelse(runif(n_ind) < udzial_bezzwrotnych, "bezzwrotna", "elastyczna"))
  efekt_nocy <- rnorm(1, 0, sd_noc)
  p_ind <- plogis(qlogis(p_przyjazd[ok, typ[typ != "grupowa"]]) + efekt_nocy)
  p_gr <- if (m > 0) rbeta(1, grupa_mu * (1 - grupa_rho) / grupa_rho, (1 - grupa_mu) * (1 - grupa_rho) / grupa_rho) else numeric(0)
  przyjazd <- c(rbinom(m, 1, rep(p_gr, m)), rbinom(n_ind, 1, p_ind))
  status <- ifelse(przyjazd == 1, "przyjazd",
                   ifelse(runif(length(typ)) < p_odwolanie_ostatnia[typ], "odwołanie < 3 dni", "no-show"))
  n_wcz <- rpois(1, sum(wczesne[typ[typ != "grupowa"]]))        # odwołane wcześniej – w danych, ale nie w księgach w dniu decyzji
  typ_wcz <- ifelse(runif(n_wcz) < 0.02 * udzial_bezzwrotnych /
                      (0.02 * udzial_bezzwrotnych + 0.30 * (1 - udzial_bezzwrotnych)), "bezzwrotna", "elastyczna")
  rez[[i]] <- data.frame(noc = kalendarz$noc[i], rok = kalendarz$rok[i], okres = ok,
                         typ = c(typ, typ_wcz), status = c(status, rep("odwołanie > 3 dni", n_wcz)))
}
rez <- do.call(rbind, rez)
rez$okres <- factor(rez$okres, levels = c("sezon", "poza"), labels = c("sezon", "poza sezonem"))
rez$id <- seq_len(nrow(rez))
rez <- rez[, c("id", "noc", "rok", "okres", "typ", "status")]
write.csv(rez, "overbooking-pensjonat-rezerwacje.csv", row.names = FALSE, fileEncoding = "UTF-8")

ks <- subset(rez, status != "odwołanie > 3 dni")     # rezerwacje w księgach w dniu decyzji (3 dni przed przyjazdem)
ks$przyjazd <- as.integer(ks$status == "przyjazd")
c(rezerwacje = nrow(rez), w_ksiegach = nrow(ks), noce = nrow(kalendarz))
table(ks$okres, ks$status)
round(100 * prop.table(table(ks$okres, ks$typ), 1), 1)          # udział typów rezerwacji (%)
noc_ks <- aggregate(cbind(rezerwacje = 1, przyjazdy = przyjazd) ~ noc + okres, data = ks, FUN = sum)
noc_ks$pelne <- as.integer(noc_ks$rezerwacje == POKOJE)
cbind(aggregate(cbind(rezerwacje, przyjazdy) ~ okres, data = noc_ks, FUN = function(x) round(mean(x), 2)),
      pelne_noce_proc = round(100 * as.vector(tapply(noc_ks$pelne, noc_ks$okres, mean)), 1))
Wynik w R
rezerwacje w_ksiegach       noce 
     21844      18757       1080 
              
               no-show odwołanie < 3 dni przyjazd
  sezon            304               481     9920
  poza sezonem     331               594     7127
              
               bezzwrotna elastyczna grupowa
  sezon              43.0       51.2     5.8
  poza sezonem       42.6       50.6     6.8
         okres rezerwacje przyjazdy pelne_noce_proc
1        sezon      23.79     22.04            92.7
2 poza sezonem      12.78     11.31             0.3

2. Odsetek przyjazdów z przedziałem Wilsona: Tabela 1

Dane wejściowe: ks z przepisu 1.

Co odczytać: liczebność, liczbę przyjazdów, p i granice 95% przedziału Wilsona dla każdego okresu i rodzaju rezerwacji; na końcu p dla rezerwacji indywidualnych w sezonie i poza nim oraz różnicę w punktach procentowych.

R
# Przepis 2. Odsetek przyjazdów (p) z 95% przedziałem Wilsona: według okresu i rodzaju rezerwacji
wilson <- function(x, n) {                            # przedział Wilsona (prop.test bez poprawki na ciągłość)
  ci <- prop.test(x, n, correct = FALSE)$conf.int
  c(n = n, przyjazdy = x, p = x / n, dol = ci[1], gora = ci[2])
}
tab_p <- do.call(rbind, lapply(split(ks, list(ks$okres, ks$typ)), function(d)
  data.frame(okres = d$okres[1], typ = d$typ[1], t(wilson(sum(d$przyjazd), nrow(d))))))
tab_p <- rbind(tab_p, do.call(rbind, lapply(split(subset(ks, typ != "grupowa"), ~ okres), function(d)
  data.frame(okres = d$okres[1], typ = "indywidualne razem", t(wilson(sum(d$przyjazd), nrow(d)))))))
tab_p <- tab_p[order(tab_p$okres, tab_p$typ), ]
rownames(tab_p) <- NULL
tab_p$p <- round(tab_p$p, 4); tab_p$dol <- round(tab_p$dol, 4); tab_p$gora <- round(tab_p$gora, 4)
tab_p
# p do dalszych obliczeń: rezerwacje indywidualne w sezonie i poza nim
ind <- subset(tab_p, typ == "indywidualne razem")
p_sezon <- ind$p[ind$okres == "sezon"]; p_poza <- ind$p[ind$okres == "poza sezonem"]
c(p_sezon = p_sezon, p_poza = p_poza, roznica_pp = round(100 * (p_sezon - p_poza), 2))
Wynik w R
         okres                typ     n przyjazdy      p    dol   gora
1        sezon         bezzwrotna  4601      4436 0.9641 0.9584 0.9691
2        sezon         elastyczna  5480      4920 0.8978 0.8895 0.9056
3        sezon            grupowa   624       564 0.9038 0.8782 0.9246
4        sezon indywidualne razem 10081      9356 0.9281 0.9229 0.9330
5 poza sezonem         bezzwrotna  3429      3281 0.9568 0.9495 0.9631
6 poza sezonem         elastyczna  4076      3359 0.8241 0.8121 0.8355
7 poza sezonem            grupowa   547       487 0.8903 0.8614 0.9138
8 poza sezonem indywidualne razem  7505      6640 0.8847 0.8773 0.8918
   p_sezon     p_poza roznica_pp 
    0.9281     0.8847     4.3400 

3. Rozkład dwumianowy liczby przyjazdów: Rysunek 2

Dane wejściowe: p_sezon (przepis 2), POKOJE, kol i motyw (przepis 1).

Co odczytać: dla N od 24 do 30: średnią liczbę przyjazdów, prawdopodobieństwo odmowy, oczekiwaną liczbę odesłanych gości i pustych pokoi.

R
# Przepis 3. Ilu gości przyjedzie przy N rezerwacjach? Rozkład dwumianowy: Rysunek 2
# S ~ Bin(N, p): liczba przyjazdów, gdy każda z N rezerwacji niezależnie kończy się przyjazdem z p
podsumuj <- function(N, p, C = POKOJE) {
  s <- 0:N; f <- dbinom(s, N, p)
  c(N = N, srednia = N * p, P_odmowa = sum(f[s > C]), odmowy = sum(pmax(s - C, 0) * f),
    puste = sum(pmax(C - s, 0) * f))
}
round(t(sapply(24:30, podsumuj, p = p_sezon)), 3)

rozk <- do.call(rbind, lapply(c(24, 25, 27), function(N)
  data.frame(N = paste("N =", N), s = 0:N, f = dbinom(0:N, N, p_sezon))))
rozk <- subset(rozk, s >= 17)
rozk$stan <- ifelse(rozk$s > POKOJE, "więcej gości niż pokoi", "wszyscy się mieszczą")
p2 <- ggplot(rozk, aes(s, f, fill = stan)) +
  geom_col(width = 0.8) +
  geom_vline(xintercept = POKOJE + 0.5, linetype = "dashed", colour = "grey20") +
  facet_wrap(~ N, ncol = 1) +
  scale_fill_manual(values = c("wszyscy się mieszczą" = kol[["niebieski"]], "więcej gości niż pokoi" = kol[["pomarancz"]]),
                    breaks = c("wszyscy się mieszczą", "więcej gości niż pokoi"), name = NULL) +
  scale_x_continuous(breaks = 17:27) +
  scale_y_continuous(labels = function(x) paste0(round(100 * x), "%")) +
  labs(title = "Liczba gości, którzy przyjadą, przy N rezerwacjach na noc w sezonie",
       subtitle = paste0("Rozkład dwumianowy, p = ", sub("^0", "", format(round(p_sezon, 3), nsmall = 3)), "; linia przerywana – 24 pokoje"),
       x = "Liczba przyjazdów", y = "Prawdopodobieństwo") +
  motyw
p2   # zapis: ggsave("overbooking-rozklad-przyjazdow.svg", p2, width = 10, height = 6.4)
Wynik w R
      N srednia P_odmowa odmowy puste
[1,] 24  22.274    0.000  0.000 1.726
[2,] 25  23.202    0.155  0.155 0.952
[3,] 26  24.131    0.433  0.577 0.446
[4,] 27  25.059    0.693  1.239 0.180
[5,] 28  25.987    0.862  2.051 0.064
[6,] 29  26.915    0.946  2.935 0.020
[7,] 30  27.843    0.982  3.849 0.006

4. Oczekiwany koszt i optymalne N, sezon i poza sezonem, rodzaj rezerwacji: Rysunek 3

Dane wejściowe: podsumuj() (przepis 3), p_sezon, p_poza, tab_p (przepis 2), ks i noc_ks (przepis 1).

Co odczytać: koszt pustych pokoi, odmów i razem (zł na noc) dla N od 24 do 34; N*, próg krytyczny, szansę mniej niż 24 przyjazdów przy N* − 1 i N*, oszczędność na noc i na sezon; skutki limitu w sezonie i poza nim; N*, koszt i prawdopodobieństwo odmowy przy różnym udziale rezerwacji bezzwrotnych.

R
# Przepis 4. Koszt pustego pokoju vs koszt odmowy: optymalne N i ryzyko w sezonie i poza nim: Rysunek 3
k_pusty <- 350                                       # utracona marża z pokoju, który stoi pusty (zł)
k_odmowa <- 750                                      # gość bez pokoju: nocleg w innym obiekcie i dojazd 450 zł + rekompensata 300 zł
koszt <- function(N, p, C = POKOJE, kp = k_pusty, ko = k_odmowa) {
  s <- 0:N; f <- dbinom(s, N, p)
  kp * sum(pmax(C - s, 0) * f) + ko * sum(pmax(s - C, 0) * f)
}
N_opt <- function(p, ...) { siatka <- 24:40; siatka[which.min(sapply(siatka, koszt, p = p, ...))] }
siatka <- 24:34
k <- data.frame(N = siatka, puste = k_pusty * sapply(siatka, function(N) podsumuj(N, p_sezon)[["puste"]]),
                odmowy = k_odmowa * sapply(siatka, function(N) podsumuj(N, p_sezon)[["odmowy"]]))
k$razem <- k$puste + k$odmowy
round(k, 1)
Ns <- N_opt(p_sezon)
c(N_opt_sezon = Ns, prog_krytyczny = round(k_odmowa / (k_odmowa + k_pusty), 3),
  P_mniej_niz_24_przy_N_opt_minus_1 = round(pbinom(POKOJE - 1, Ns - 1, p_sezon), 3),
  P_mniej_niz_24_przy_N_opt = round(pbinom(POKOJE - 1, Ns, p_sezon), 3),
  oszczednosc_na_noc = round(koszt(24, p_sezon) - koszt(Ns, p_sezon), 1),
  oszczednosc_na_sezon_150_nocy = round(150 * (koszt(24, p_sezon) - koszt(Ns, p_sezon))))
# Poza sezonem: inne p, więc inne N*. Co się stanie, gdy limit spoza sezonu zostanie w sezonie?
N_poza <- N_opt(p_poza)
round(rbind(sezon = podsumuj(Ns, p_sezon), poza_sezonem = podsumuj(N_poza, p_poza),
            sezon_z_limitem_spoza_sezonu = podsumuj(N_poza, p_sezon)), 3)
c(N_opt_poza = N_poza, koszt_sezon_z_limitem_spoza = round(koszt(N_poza, p_sezon), 1),
  noce_poza_sezonem_z_co_najmniej_24_rez_proc = round(100 * mean(noc_ks$rezerwacje[noc_ks$okres == "poza sezonem"] >= 24), 1))
# Rodzaj rezerwacji: N* przy samych bezzwrotnych, obecnym udziale i samych elastycznych (sezon)
p_typ <- setNames(tab_p$p[tab_p$okres == "sezon"], tab_p$typ[tab_p$okres == "sezon"])
koszt_mix <- function(N, f_b, pb = p_typ[["bezzwrotna"]], pe = p_typ[["elastyczna"]]) {
  nb <- round(f_b * N); fs <- convolve(dbinom(0:nb, nb, pb), rev(dbinom(0:(N - nb), N - nb, pe)), type = "open")
  s <- 0:N; fs <- pmax(fs, 0)
  c(N = N, koszt = k_pusty * sum(pmax(POKOJE - s, 0) * fs) + k_odmowa * sum(pmax(s - POKOJE, 0) * fs),
    P_odmowa = sum(fs[s > POKOJE]))
}
f_b_sezon <- with(subset(ks, okres == "sezon" & typ != "grupowa"), mean(typ == "bezzwrotna"))
mix <- do.call(rbind, lapply(c(samych_bezzwrotnych = 1, obecny_udzial = f_b_sezon, samych_elastycznych = 0), function(f) {
  w <- t(sapply(24:36, koszt_mix, f_b = f)); w[which.min(w[, "koszt"]), ] }))
cbind(udzial_bezzwrotnych = round(c(1, f_b_sezon, 0), 3), round(mix, 3))

et <- paste0(c("sezon (p = ", "poza sezonem (p = "), sub("^0", "", format(round(c(p_sezon, p_poza), 3), nsmall = 3)), ")")
ryz <- rbind(data.frame(okres = et[1], N = 24:30, P = sapply(24:30, function(N) podsumuj(N, p_sezon)[["P_odmowa"]])),
             data.frame(okres = et[2], N = 24:30, P = sapply(24:30, function(N) podsumuj(N, p_poza)[["P_odmowa"]])))
ryz$okres <- factor(ryz$okres, levels = et)
kw <- subset(k, N <= 30)
kd <- rbind(data.frame(N = kw$N, skladnik = "puste pokoje", zl = kw$puste),
            data.frame(N = kw$N, skladnik = "odmowy", zl = kw$odmowy),
            data.frame(N = kw$N, skladnik = "razem", zl = kw$razem))
pa <- ggplot(kd, aes(N, zl, colour = skladnik, linetype = skladnik, shape = skladnik)) +
  geom_line(linewidth = 0.9) + geom_point(size = 2.4) +
  annotate("point", x = Ns, y = min(k$razem), size = 5, shape = 21, colour = "grey10", stroke = 1.2) +
  annotate("text", x = Ns, y = min(k$razem) + 420, label = paste0("N* = ", Ns), fontface = "bold", size = 4.2) +
  scale_colour_manual(values = c("puste pokoje" = kol[["niebieski"]], "odmowy" = kol[["pomarancz"]], "razem" = "grey15"), name = NULL) +
  scale_linetype_manual(values = c("puste pokoje" = "dashed", "odmowy" = "dotdash", "razem" = "solid"), name = NULL) +
  scale_shape_manual(values = c("puste pokoje" = 16, "odmowy" = 17, "razem" = 15), name = NULL) +
  scale_x_continuous(breaks = 24:30) +
  labs(title = "A. Oczekiwany koszt na noc (sezon)", x = "Przyjęte rezerwacje N", y = "zł na noc") + motyw
pb <- ggplot(ryz, aes(N, P, colour = okres, shape = okres)) +
  geom_line(linewidth = 0.9) + geom_point(size = 2.4) +
  scale_colour_manual(values = c(kol[["pomarancz"]], kol[["niebieski"]]), name = NULL) +
  scale_shape_manual(values = c(17, 16), name = NULL) +
  scale_x_continuous(breaks = 24:30) +
  scale_y_continuous(labels = function(x) paste0(round(100 * x), "%")) +
  guides(colour = guide_legend(ncol = 1), shape = guide_legend(ncol = 1)) +
  labs(title = "B. Szansa, że komuś zabraknie pokoju", x = "Przyjęte rezerwacje N", y = "P(więcej gości niż 24)") + motyw
p3 <- patchwork::wrap_plots(pa, pb, ncol = 2)
p3   # zapis: ggsave("overbooking-koszt-oczekiwany.svg", p3, width = 10, height = 5.6)
Wynik w R
    N puste odmowy  razem
1  24 604.0    0.0  604.0
2  25 333.3  116.1  449.4
3  26 156.2  432.6  588.8
4  27  63.1  929.3  992.4
5  28  22.4 1538.1 1560.5
6  29   7.1 2201.4 2208.5
7  30   2.0 2886.6 2888.7
8  31   0.5 3579.5 3580.0
9  32   0.1 4274.7 4274.8
10 33   0.0 4970.5 4970.6
11 34   0.0 5666.6 5666.6
                      N_opt_sezon                    prog_krytyczny P_mniej_niz_24_przy_N_opt_minus_1 
                           25.000                             0.682                             0.833 
        P_mniej_niz_24_przy_N_opt                oszczednosc_na_noc     oszczednosc_na_sezon_150_nocy 
                            0.545                           154.500                         23177.000 
                              N srednia P_odmowa odmowy puste
sezon                        25  23.202    0.155  0.155 0.952
poza_sezonem                 26  23.002    0.182  0.223 1.221
sezon_z_limitem_spoza_sezonu 26  24.131    0.433  0.577 0.446
                                 N_opt_poza                 koszt_sezon_z_limitem_spoza 
                                       26.0                                       588.8 
noce_poza_sezonem_z_co_najmniej_24_rez_proc 
                                        0.3 
                    udzial_bezzwrotnych  N   koszt P_odmowa
samych_bezzwrotnych               1.000 24 301.560    0.000
obecny_udzial                     0.456 25 451.643    0.148
samych_elastycznych               0.000 26 560.782    0.240

5. Bootstrap nocy i analiza wrażliwości na koszt odmowy: Rysunek 4

Dane wejściowe: ks (przepis 1), tab_p i p_sezon (przepis 2), koszt() i N_opt() (przepis 4).

Co odczytać: przedział Wilsona i przedział z bootstrapu nocy, rozkład N* w 2000 losowaniach, koszt uśredniony po niepewności p, wartości p, przy których zmienia się N*, zakresy kosztu odmowy dla każdego N* i zysk z sezonu przy kosztach odmowy 750, 1500 i 3000 zł.

R
# Przepis 5. Niepewność p (bootstrap nocy) i wrażliwość N* na koszt odmowy: Rysunek 4
# Losujemy ze zwracaniem całe noce sezonu – rezerwacje z tej samej nocy łączy pogoda i stan dróg
ind_s <- subset(ks, okres == "sezon" & typ != "grupowa")
po_nocach <- aggregate(cbind(n = 1, x = przyjazd) ~ noc, data = ind_s, FUN = sum)
B <- 2000
set.seed(7521)
p_boot <- replicate(B, { i <- sample(nrow(po_nocach), replace = TRUE); sum(po_nocach$x[i]) / sum(po_nocach$n[i]) })
wilson_s <- unlist(tab_p[tab_p$okres == "sezon" & tab_p$typ == "indywidualne razem", c("dol", "gora")])
round(rbind(wilson = wilson_s, bootstrap_nocy = quantile(p_boot, c(0.025, 0.975))), 4)
N_boot <- sapply(p_boot, N_opt)
table(N_boot)                                        # N* w 2000 losowaniach bootstrapu
# Oczekiwany koszt na noc uśredniony po niepewności p (dla każdego N)
k_boot <- sapply(24:28, function(N) mean(sapply(p_boot, koszt, N = N)))
round(rbind(N = 24:28, przy_p_punktowym = sapply(24:28, koszt, p = p_sezon), usredniony_po_p = k_boot), 1)
# Przy jakim p zmienia się N*? (próg między 25 a 26)
p_siatka <- seq(0.85, 0.99, by = 0.0005)
N_p <- sapply(p_siatka, N_opt)
c(p_od_ktorego_N_25 = max(p_siatka[N_p >= 26]), p_od_ktorego_N_24 = max(p_siatka[N_p >= 25]))

# Analiza wrażliwości: koszt odmowy od 350 do 3500 zł (reputacja – trudna do wyceny)
ko_siatka <- seq(350, 3500, by = 25)
wr <- do.call(rbind, lapply(c(dolna = wilson_s[[1]], punktowe = p_sezon, gorna = wilson_s[[2]]), function(pp)
  data.frame(p = pp, ko = ko_siatka, N = sapply(ko_siatka, function(ko) N_opt(pp, ko = ko)))))
wr$wariant <- factor(rep(c("dolna granica CI", "p punktowe", "górna granica CI"), each = length(ko_siatka)),
                     levels = c("dolna granica CI", "p punktowe", "górna granica CI"))
aggregate(ko ~ N + wariant, data = wr, FUN = function(x) paste(range(x), collapse = "–"))
roczny <- sapply(c(750, 1500, 3000), function(ko) 150 * (koszt(24, p_sezon, ko = ko) - koszt(N_opt(p_sezon, ko = ko), p_sezon, ko = ko)))
setNames(round(roczny), c("zysk_sezon_ko_750", "zysk_sezon_ko_1500", "zysk_sezon_ko_3000"))

bt <- as.data.frame(table(N = N_boot)); bt$udzial <- bt$Freq / B
progi <- c(max(p_siatka[N_p >= 26]), max(p_siatka[N_p >= 25]))
strefy <- data.frame(od = c(0.89, progi), do = c(progi, 0.965), N = paste("N* =", 26:24))
pa <- ggplot() +
  geom_rect(data = strefy, aes(xmin = od, xmax = do, ymin = -Inf, ymax = Inf, fill = N), alpha = 0.35) +
  geom_histogram(data = data.frame(p = p_boot), aes(p), binwidth = 0.0005, fill = "grey25") +
  geom_vline(xintercept = progi, linetype = "dashed", colour = "grey30") +
  geom_text(data = strefy, aes(x = (od + do) / 2, y = Inf, label = N), vjust = 1.6, size = 4, fontface = "bold") +
  scale_fill_manual(values = c("N* = 26" = kol[["pomarancz"]], "N* = 25" = "grey85", "N* = 24" = kol[["niebieski"]]), guide = "none") +
  scale_x_continuous(breaks = seq(0.89, 0.96, 0.01), labels = function(x) sub("^0", "", format(x, nsmall = 2))) +
  coord_cartesian(xlim = c(0.89, 0.965), expand = FALSE) +
  labs(title = "A. p z 2000 losowań nocy a progi N*", x = "Odsetek przyjazdów p (sezon)", y = "Liczba losowań") + motyw
pb <- ggplot(wr, aes(ko, N, colour = wariant, linetype = wariant)) +
  geom_step(linewidth = 1, position = position_nudge(y = rep(c(-0.08, 0, 0.08), each = length(ko_siatka)))) +
  geom_vline(xintercept = k_odmowa, colour = "grey30", linetype = "dotted") +
  annotate("text", x = k_odmowa + 60, y = 26.4, label = "750 zł", hjust = 0, size = 3.8, colour = "grey30") +
  scale_colour_manual(values = c(kol[["niebieski"]], "grey15", kol[["pomarancz"]]), name = NULL) +
  scale_linetype_manual(values = c("dashed", "solid", "dotdash"), name = NULL) +
  scale_y_continuous(breaks = 24:29) +
  guides(colour = guide_legend(ncol = 1), linetype = guide_legend(ncol = 1)) +
  labs(title = "B. N* a koszt odmowy", x = "Koszt jednej odmowy (zł)", y = "Optymalne N*") + motyw
p4 <- patchwork::wrap_plots(pa, pb, ncol = 2)
p4   # zapis: ggsave("overbooking-niepewnosc-p.svg", p4, width = 10, height = 5.6)
Wynik w R
                  dol   gora
wilson         0.9229 0.9330
bootstrap_nocy 0.9228 0.9336
N_boot
  25 
2000 
                  [,1]  [,2]  [,3]  [,4]   [,5]
N                 24.0  25.0  26.0  27.0   28.0
przy_p_punktowym 604.0 449.4 588.8 992.4 1560.5
usredniony_po_p  603.6 449.7 589.9 993.7 1561.8
p_od_ktorego_N_25 p_od_ktorego_N_24 
            0.908             0.953 
   N          wariant        ko
1 24 dolna granica CI 2075–3500
2 25 dolna granica CI  500–2050
3 26 dolna granica CI   350–475
4 24       p punktowe 1750–3500
5 25       p punktowe  425–1725
6 26       p punktowe   350–400
7 24 górna granica CI 1500–3500
8 25 górna granica CI  375–1475
9 26 górna granica CI   350–350
 zysk_sezon_ko_750 zysk_sezon_ko_1500 zysk_sezon_ko_3000 
             23177               5759                  0 

6. Rezerwacje grupowe: rozkład beta-dwumianowy: Rysunek 5

Dane wejściowe: ks (przepis 1), p_sezon (przepis 2), k_pusty i k_odmowa (przepis 4).

Co odczytać: liczbę grup i pokoi, μ i ρ z 95% przedziałem dla ρ, statystykę LR i jej p, wariancję liczby przyjazdów w grupie 8 pokoi w obu modelach oraz prawdopodobieństwo odmowy, oczekiwaną liczbę odmów i koszt w nocy z grupą; na końcu N* w obu modelach.

R
# Przepis 6. Rezerwacje grupowe: odwołania zależne – rozkład beta-dwumianowy: Rysunek 5
gr <- aggregate(cbind(m = 1, x = przyjazd) ~ noc + okres, data = subset(ks, typ == "grupowa"), FUN = sum)
c(grupy = nrow(gr), pokoje = sum(gr$m), p_przyjazdu = round(sum(gr$x) / sum(gr$m), 4),
  cale_grupy_nieobecne = sum(gr$x == 0), grupy_w_komplecie = sum(gr$x == gr$m))
# Logarytm wiarygodności beta-dwumianowego: mu – średnie p, rho – korelacja przyjazdów w grupie
ll_bb <- function(th, x, m) {
  mu <- plogis(th[1]); rho <- plogis(th[2]); a <- mu * (1 - rho) / rho; b <- (1 - mu) * (1 - rho) / rho
  sum(lchoose(m, x) + lbeta(x + a, m - x + b) - lbeta(a, b))
}
fit <- optim(c(qlogis(0.9), qlogis(0.1)), ll_bb, x = gr$x, m = gr$m, control = list(fnscale = -1), hessian = TRUE)
mu_g <- plogis(fit$par[1]); rho_g <- plogis(fit$par[2])
ll_bin <- sum(dbinom(gr$x, gr$m, sum(gr$x) / sum(gr$m), log = TRUE))
se <- sqrt(diag(solve(-fit$hessian)))
LR <- 2 * (fit$value - ll_bin)
round(c(mu = mu_g, rho = rho_g, rho_dol = plogis(fit$par[2] - 1.96 * se[2]),
        rho_gora = plogis(fit$par[2] + 1.96 * se[2]), LR = LR), 4)
0.5 * pchisq(LR, 1, lower.tail = FALSE)              # p testu rho = 0 (wartość na brzegu: połowa p z chi-kwadrat(1))
# Wariancja liczby przyjazdów w grupie 8 pokoi: dwumianowy vs beta-dwumianowy
c(war_dwumianowy = round(8 * mu_g * (1 - mu_g), 3), war_beta_dwumianowy = round(8 * mu_g * (1 - mu_g) * (1 + 7 * rho_g), 3))

d_bb <- function(m, mu, rho) {                       # rozkład beta-dwumianowy dla 0..m
  a <- mu * (1 - rho) / rho; b <- (1 - mu) * (1 - rho) / rho
  exp(lchoose(m, 0:m) + lbeta(0:m + a, m - 0:m + b) - lbeta(a, b))
}
# Noc w sezonie: grupa 8 pokoi + (N − 8) rezerwacji indywidualnych
noc_z_grupa <- function(N, model, m = 8) {
  f_gr <- if (model == "beta-dwumianowy") d_bb(m, mu_g, rho_g) else dbinom(0:m, m, mu_g)
  fs <- pmax(convolve(f_gr, rev(dbinom(0:(N - m), N - m, p_sezon)), type = "open"), 0)
  s <- 0:N
  c(N = N, P_odmowa = sum(fs[s > POKOJE]), odmowy = sum(pmax(s - POKOJE, 0) * fs),
    koszt = k_pusty * sum(pmax(POKOJE - s, 0) * fs) + k_odmowa * sum(pmax(s - POKOJE, 0) * fs))
}
gn <- do.call(rbind, lapply(c("dwumianowy", "beta-dwumianowy"), function(md)
  data.frame(model = md, t(sapply(24:30, noc_z_grupa, model = md)))))
gn$P_odmowa <- round(gn$P_odmowa, 3); gn$odmowy <- round(gn$odmowy, 3); gn$koszt <- round(gn$koszt, 1)
gn
sapply(split(gn, gn$model), function(d) d$N[which.min(d$koszt)])     # N* w nocy z grupą

gn$model <- factor(gn$model, levels = c("dwumianowy", "beta-dwumianowy"),
                   labels = c("grupa jak 8 osobnych rezerwacji (dwumianowy)", "grupa odwołuje razem (beta-dwumianowy)"))
p5 <- ggplot(gn, aes(N, P_odmowa, colour = model, shape = model, linetype = model)) +
  geom_line(linewidth = 1) + geom_point(size = 2.6) +
  geom_text(data = subset(gn, N %in% 25:26 & model == levels(model)[1]), aes(label = paste0(round(100 * P_odmowa, 1), "%")),
            hjust = -0.3, vjust = 1.2, size = 3.8, show.legend = FALSE) +
  geom_text(data = subset(gn, N %in% 25:26 & model == levels(model)[2]), aes(label = paste0(round(100 * P_odmowa, 1), "%")),
            hjust = 1.3, vjust = -0.4, size = 3.8, show.legend = FALSE) +
  scale_colour_manual(values = c(kol[["niebieski"]], kol[["pomarancz"]]), name = NULL) +
  scale_shape_manual(values = c(16, 17), name = NULL) +
  scale_linetype_manual(values = c("dashed", "solid"), name = NULL) +
  scale_x_continuous(breaks = 24:30) +
  scale_y_continuous(labels = function(x) paste0(round(100 * x), "%"), limits = c(0, 1)) +
  guides(colour = guide_legend(ncol = 1), shape = guide_legend(ncol = 1), linetype = guide_legend(ncol = 1)) +
  labs(title = "Noc w sezonie z grupą 8 pokoi: szansa, że komuś zabraknie pokoju",
       subtitle = minus(paste0("Grupa: średnie p = ", sub("^0", "", format(round(mu_g, 3), nsmall = 3)),
                               ", korelacja w grupie ρ = ", sub("^0", "", format(round(rho_g, 2), nsmall = 2)))),
       x = "Przyjęte rezerwacje N (w tym 8 grupowych)", y = "P(więcej gości niż 24)") + motyw
p5   # zapis: ggsave("overbooking-grupy-beta-dwumianowy.svg", p5, width = 10, height = 5.6)
Wynik w R
               grupy               pokoje          p_przyjazdu cale_grupy_nieobecne    grupy_w_komplecie 
            198.0000            1171.0000               0.8975               1.0000             139.0000 
      mu      rho  rho_dol rho_gora       LR 
  0.8975   0.2936   0.2054   0.4005 110.4530 
[1] 3.898698e-26
     war_dwumianowy war_beta_dwumianowy 
              0.736               2.248 
             model  N P_odmowa odmowy  koszt
1       dwumianowy 24    0.000  0.000  689.6
2       dwumianowy 25    0.118  0.118  495.0
3       dwumianowy 26    0.364  0.473  560.8
4       dwumianowy 27    0.624  1.072  894.1
5       dwumianowy 28    0.815  1.842 1415.9
6       dwumianowy 29    0.921  2.704 2040.3
7       dwumianowy 30    0.971  3.609 2710.4
8  beta-dwumianowy 24    0.000  0.000  689.6
9  beta-dwumianowy 25    0.185  0.185  568.6
10 beta-dwumianowy 26    0.449  0.621  723.0
11 beta-dwumianowy 27    0.662  1.251 1090.8
12 beta-dwumianowy 28    0.797  2.000 1590.6
13 beta-dwumianowy 29    0.877  2.820 2167.3
14 beta-dwumianowy 30    0.925  3.682 2790.4
beta-dwumianowy      dwumianowy 
             25              25 

7. Pułapka: trzy definicje nieobecności: Rysunek 6

Dane wejściowe: rez (przepis 1), p_sezon (przepis 2), N_opt(), koszt(), Ns (przepis 4), podsumuj() (przepis 3).

Co odczytać: statusy rezerwacji indywidualnych w sezonie, p i N* przy każdej definicji oraz skutek limitu przy poprawnym p: odsetek nocy z odmową, liczbę odmów na sezon, koszt na noc i stratę na sezon względem N*.

R
# Przepis 7. Pułapka: co liczymy jako „nie przyjechał”? Trzy definicje p: Rysunek 6
wsz_s <- subset(rez, okres == "sezon" & typ != "grupowa")      # z odwołaniami > 3 dni przed przyjazdem
tab_st <- table(wsz_s$status)
tab_st
w_ks <- sum(tab_st[c("przyjazd", "no-show", "odwołanie < 3 dni")])
defs <- data.frame(definicja = c("tylko no-show", "no-show + odwołanie < 3 dni (poprawnie)", "wszystkie odwołania"),
                   x = c(w_ks - tab_st[["no-show"]], tab_st[["przyjazd"]], tab_st[["przyjazd"]]),
                   n = c(w_ks, w_ks, sum(tab_st)))
defs$p <- defs$x / defs$n
defs$N_opt <- sapply(defs$p, N_opt)
# Skutek limitu N wyznaczonego z każdej definicji, oceniony przy poprawnym p (sezon)
defs$P_odmowa <- sapply(defs$N_opt, function(N) podsumuj(N, p_sezon)[["P_odmowa"]])
defs$odmowy_na_sezon <- 150 * sapply(defs$N_opt, function(N) podsumuj(N, p_sezon)[["odmowy"]])
defs$koszt_na_noc <- sapply(defs$N_opt, koszt, p = p_sezon)
defs$strata_na_sezon <- 150 * (defs$koszt_na_noc - koszt(Ns, p_sezon))
cbind(defs[, 1:3], round(defs[, -(1:3)], 3))

defs$definicja <- factor(defs$definicja, levels = defs$definicja)
pa <- ggplot(defs, aes(p, definicja, colour = definicja, shape = definicja)) +
  geom_point(size = 4) +
  geom_text(aes(label = sub("^0", "", format(round(p, 3), nsmall = 3))), vjust = -1.1, size = 4, show.legend = FALSE) +
  scale_colour_manual(values = c(kol[["niebieski"]], "grey15", kol[["pomarancz"]]), guide = "none") +
  scale_shape_manual(values = c(16, 15, 17), guide = "none") +
  scale_x_continuous(limits = c(0.75, 1), labels = function(x) sub("^0", "", format(x, nsmall = 2))) +
  scale_y_discrete(labels = function(x) gsub(" \\(", "\n(", x), limits = rev) +
  labs(title = "A. Szacowane p", x = "Odsetek przyjazdów", y = NULL) + motyw
pb <- ggplot(defs, aes(factor(N_opt), P_odmowa, fill = definicja)) +
  geom_col(width = 0.6) +
  geom_text(aes(label = paste0(round(100 * P_odmowa, 1), "%\n", round(odmowy_na_sezon), " odmów/sezon")),
            vjust = -0.25, size = 3.6, lineheight = 0.9) +
  scale_fill_manual(values = c(kol[["niebieski"]], "grey15", kol[["pomarancz"]]), guide = "none") +
  scale_y_continuous(labels = function(x) paste0(round(100 * x), "%"), limits = c(0, 1.12)) +
  scale_x_discrete(expand = expansion(add = 0.75)) +
  labs(title = "B. Skutek limitu w sezonie", x = "Limit N* z danej definicji", y = "Noce z odmową") + motyw
p6 <- patchwork::wrap_plots(pa, pb, ncol = 2, widths = c(1.1, 1))
p6   # zapis: ggsave("overbooking-definicja-nieobecnosci.svg", p6, width = 10, height = 5.6)
Wynik w R

          no-show odwołanie < 3 dni odwołanie > 3 dni          przyjazd 
              293               432              1790              9356 
                                definicja    x     n     p N_opt P_odmowa odmowy_na_sezon koszt_na_noc strata_na_sezon
1                           tylko no-show 9788 10081 0.971    24    0.000           0.000      603.960        23177.47
2 no-show + odwołanie < 3 dni (poprawnie) 9356 10081 0.928    25    0.155          23.225      449.444            0.00
3                     wszystkie odwołania 9356 11871 0.788    29    0.946         440.279     2208.494       263857.63

8. Grafika: karta „24 pokoje, ile rezerwacji?”: Rysunek 1

Dane wejściowe: k, Ns, k_pusty, k_odmowa (przepis 4), wilson_s, wr (przepis 5), gn (przepis 6) i pozostałe obiekty z przepisów 1–3.

Co odczytać: przepis niczego nie wypisuje – rysuje kartę z liczbami pobranymi z wcześniejszych przepisów.

R
# Przepis 8. Grafika: karta „24 pokoje, ile rezerwacji?”: Rysunek 1
f3 <- function(x) sub("^0", "", format(round(x, 3), nsmall = 3))
zl <- function(x) paste(format(round(x), big.mark = " "), "zł")
pokoje <- expand.grid(kol_ = 1:6, wiersz = 1:4)
pokoje$x <- (pokoje$kol_ - 1) * 1.1; pokoje$y <- (4 - pokoje$wiersz) * 1.1 + 0.6
extra <- data.frame(x = 6 * 1.1, y = 3 * 1.1 + 0.6)              # rezerwacja ponad pojemność (N* − 24 = 1)
kp <- k[k$N == 24, "razem"]; kn <- k[k$N == Ns, "razem"]
gr25 <- gn[gn$N == 25, ]
karty <- data.frame(
  x = 7.9, y = c(5.0, 3.75, 2.5, 1.25, 0),
  naglowek = c("Ile osób przyjeżdża?", "Co kosztuje pomyłka?", "Ile rezerwacji przyjąć?", "Ryzyko przy N* = 25",
               "Uwaga na grupy i reputację"),
  tresc = c(paste0("p = ", f3(p_sezon), " [", f3(wilson_s[1]), ", ", f3(wilson_s[2]), "] w sezonie,\n", f3(p_poza), " poza sezonem"),
            paste0("pusty pokój ", zl(k_pusty), ", odmowa ", zl(k_odmowa), "\n(relokacja + rekompensata)"),
            paste0("N* = ", Ns, " – o jedną ponad pojemność;\nzysk ", zl(150 * (kp - kn)), " na sezon (150 nocy)"),
            paste0("odmowa w ", round(100 * podsumuj(Ns, p_sezon)[["P_odmowa"]], 1), "% nocy; puste średnio\n",
                   round(podsumuj(Ns, p_sezon)[["puste"]], 2), " pokoju zamiast ", round(podsumuj(24, p_sezon)[["puste"]], 2)),
            paste0("grupa 8 pokoi: odmowa w ", round(100 * gr25$P_odmowa[2], 1), "% zamiast ", round(100 * gr25$P_odmowa[1], 1),
                   "% nocy;\nodmowa od ", min(wr$ko[wr$wariant == "p punktowe" & wr$N == 24]), " zł → N = 24")))
p1 <- ggplot() +
  geom_rect(data = pokoje, aes(xmin = x, xmax = x + 1, ymin = y, ymax = y + 1), fill = "#D6E6F2", colour = kol[["niebieski"]], linewidth = 0.6) +
  geom_text(data = pokoje, aes(x + 0.5, y + 0.5, label = seq_len(nrow(pokoje))), size = 4.2, colour = "#0f1d3a") +
  geom_rect(data = extra, aes(xmin = x, xmax = x + 1, ymin = y, ymax = y + 1), fill = "#FBE3D6", colour = kol[["pomarancz"]],
            linewidth = 0.9, linetype = "dashed") +
  annotate("text", x = 6.6 + 0.5, y = 3.3 + 0.6 + 0.5, label = "+1", fontface = "bold", size = 4.2, colour = kol[["pomarancz"]]) +
  annotate("text", x = 0, y = 0.3, label = "24 pokoje (niebieskie) + 1 rezerwacja\nponad pojemność (przerywana)",
           hjust = 0, vjust = 1, size = 4, lineheight = 0.95, colour = "grey25") +
  annotate("text", x = 0, y = -0.85, hjust = 0, vjust = 1, label = paste0("Bez overbookingu: średnio ", round(podsumuj(24, p_sezon)[["puste"]], 2),
                                                      " pustego\npokoju na noc"), size = 4, lineheight = 0.95, colour = "grey25") +
  geom_rect(data = karty, aes(xmin = x, xmax = x + 10, ymin = y - 0.55, ymax = y + 0.58), fill = "grey97", colour = "grey75") +
  geom_text(data = karty, aes(x + 0.2, y + 0.33, label = naglowek), hjust = 0, fontface = "bold", size = 4.5, colour = "#0f1d3a") +
  geom_text(data = karty, aes(x + 0.2, y - 0.2, label = tresc), hjust = 0, size = 4, lineheight = 0.95, colour = "grey15") +
  annotate("text", x = 0, y = 6.45, label = "24 pokoje, ile rezerwacji?", hjust = 0, fontface = "bold", size = 6.5, colour = "#0f1d3a") +
  annotate("text", x = 0, y = 5.95, label = "Pensjonat w górach – noc w sezonie,\ndecyzja 3 dni przed przyjazdem (dane fikcyjne)",
           hjust = 0, vjust = 1, size = 4, lineheight = 0.95, colour = "grey30") +
  coord_equal(xlim = c(0, 18), ylim = c(-1.7, 6.8), expand = FALSE) +
  theme_void() + theme(plot.background = element_rect(fill = "white", colour = NA), plot.margin = margin(10, 10, 10, 10))
p1   # zapis: ggsave("overbooking-karta-24-pokoje.svg", p1, width = 10, height = 4.9)

9. Kontrola palety: symulacja zaburzeń widzenia barw

Dane wejściowe: pary kolorów z rysunków i – dla porównania – para czerwony–zielony.

Co odczytać: odległość barw ΔE w przestrzeni CIELAB przy typowym widzeniu oraz po symulacji deuteranopii i protanopii. Na rysunkach kolorowi towarzyszy kształt punktu, rodzaj linii albo etykieta, a na karcie – przerywana ramka.

R
# Przepis 9. Kontrola palety: symulacja zaburzeń widzenia barw
library(colorspace)
roznica <- function(k) {                             # odległość dwóch barw w przestrzeni CIELAB (ΔE)
  lab <- coords(as(hex2RGB(k), "LAB"))
  sqrt(sum((lab[1, ] - lab[2, ])^2))
}
pary <- list("niebieski – pomarańczowy" = c("#0072B2", "#D55E00"), "niebieski – grafit" = c("#0072B2", "#262626"),
             "pomarańczowy – grafit" = c("#D55E00", "#262626"), "pokój – rezerwacja ponad" = c("#D6E6F2", "#FBE3D6"),
             "czerwony – zielony (do unikania)" = c("#E41A1C", "#4DAF4A"))
round(t(sapply(pary, function(k) c(widzenie_typowe = roznica(k), deuteranopia = roznica(deutan(k)),
                                   protanopia = roznica(protan(k))))), 1)
Wynik w R
                                 widzenie_typowe deuteranopia protanopia
niebieski – pomarańczowy                   114.6        108.3       91.9
niebieski – grafit                          51.7         53.3       51.3
pomarańczowy – grafit                       86.0         75.9       62.8
pokój – rezerwacja ponad                    19.3         18.6       15.7
czerwony – zielony (do unikania)           121.7         21.1       31.6

Bibliografia oprogramowania

Wyniki na tej stronie pochodzą z uruchomienia pokazanego kodu w R 4.5.3. Losowanie danych, przedziały Wilsona (prop.test), rozkład dwumianowy (dbinom, pbinom), splot rozkładów (convolve) i estymacja metodą największej wiarygodności (optim) – pakiet stats i funkcje podstawowej instalacji R. Rysunki wykonano w pakiecie ggplot2, panele złożono pakietem patchwork i zapisano pakietem svglite, a paletę sprawdzono pakietem colorspace. W pracy podaj wersje faktycznie użytych pakietów (sessionInfo()).

  1. R: R Core Team. (2026). R: A language and environment for statistical computing (Version 4.5.3) [Computer software]. R Foundation for Statistical Computing. https://www.R-project.org/
  2. ggplot2 (wersja 4.0.2): Wickham, H. (2016). ggplot2: Elegant graphics for data analysis. Springer. https://ggplot2.tidyverse.org
  3. patchwork (wersja 1.3.2): Pedersen, T. L. (2025). patchwork: The composer of plots [R package]. https://doi.org/10.32614/CRAN.package.patchwork
  4. colorspace (wersja 2.1.2): Zeileis, A., Fisher, J. C., Hornik, K., Ihaka, R., McWhite, C. D., Murrell, P., Stauffer, R., & Wilke, C. O. (2020). colorspace: A toolbox for manipulating and assessing colors and palettes. Journal of Statistical Software, 96(1). https://doi.org/10.18637/jss.v096.i01
  5. svglite (wersja 2.2.2): Wickham, H., Henry, L., Pedersen, T. L., Luciani, T. J., Decorde, M., & Lise, V. (2025). svglite: An 'SVG' graphics device [R package]. https://doi.org/10.32614/CRAN.package.svglite

Pułapki

  • Późne odwołanie a no-show. Oba zostawiają pusty pokój (rysunek 6), różni je rozliczenie: przy rezerwacji bezzwrotnej no-show i tak płaci. Licząc zysk, a nie tylko puste pokoje, uwzględnij oba przychody.
  • Jedno p na cały rok. Limit spoza sezonu (26) w sezonie daje odmowę w 43.3% nocy. Licz p dla okresów, w których stosujesz limit.
  • Niezależność to założenie. Grupy i pogoda zwiększają rozrzut liczby przyjazdów. U nas wpływ nocy był mały, grup – wyraźny. Nadmierne rozproszenie sprawdzaj, zanim zaufasz modelowi dwumianowemu.
  • Koszt odmowy tylko w złotówkach. Odesłany gość może wystawić złą opinię. Pokaż, przy jakiej kwocie decyzja się zmienia (u nas między 1725 a 1750 zł).
  • Historia bez overbookingu. Nie wiemy, czy goście „nadmiarowych” rezerwacji zachowają się tak samo. Po wprowadzeniu limitu sprawdzaj p na nowych danych.

Najczęstsze pytania

Ile rezerwacji można przyjąć ponad liczbę pokoi?

Tyle, przy ilu oczekiwany koszt pustych pokoi i odesłanych gości jest najmniejszy. Liczbę przyjazdów opisz rozkładem dwumianowym z odsetkiem przyjazdów z własnych danych i dokładaj rezerwację, dopóki szansa, że przyjedzie mniej gości niż pokoi, przekracza koszt odmowy / (koszt odmowy + koszt pustego pokoju). W przykładzie z 24 pokojami, p = .928 i kosztami 750 i 350 zł wychodzi 25 rezerwacji.

Jak policzyć odsetek przyjazdów do overbookingu?

Weź rezerwacje aktywne w chwili decyzji (u nas 3 dni przed przyjazdem) i policz, jaka ich część zakończyła się przyjazdem; nieobecni to no-show i późne odwołania. Wcześniejszych odwołań nie wliczaj, bo pokój sprzedano ponownie. W przykładzie inne definicje dawały p = .971 albo .788 zamiast .928 i limit 24 albo 29 zamiast 25.

Czy overbooking opłaca się przy rezerwacjach bezzwrotnych?

Zwykle mniej. Gość z rezerwacją bezzwrotną przyjeżdża częściej (w przykładzie p = .964 wobec .898 przy rezerwacji elastycznej), więc puste pokoje zdarzają się rzadziej. Przy samych rezerwacjach bezzwrotnych optymalne było 24 rezerwacje, czyli brak overbookingu, przy samych elastycznych – 26.

Dlaczego rezerwacje grupowe zwiększają ryzyko overbookingu?

Bo goście z jednej grupy przyjeżdżają albo rezygnują razem, więc liczba przyjazdów ma większy rozrzut niż w rozkładzie dwumianowym. Opisuje to rozkład beta-dwumianowy: w przykładzie korelacja w grupie wyniosła .29, a przy 25 rezerwacjach z grupą 8 pokoi szansa odmowy wzrosła z 11.8% do 18.5%.

Jak uwzględnić w overbookingu koszt utraty reputacji?

Nie zgaduj jednej kwoty – zrób analizę wrażliwości: policz optymalną liczbę rezerwacji dla kosztu odmowy w szerokim zakresie i podaj, od jakiej kwoty decyzja się zmienia. W przykładzie 25 rezerwacji było najlepsze przy koszcie odmowy od 425 do 1725 zł, a od 1750 zł overbooking przestawał się opłacać.

Powiązane hasła

Przeczytaj też

Piszesz pracę o rezerwacjach albo ustalasz limity w obiekcie?

Pomożemy policzyć odsetek przyjazdów, dobrać rozkład i koszty, wyznaczyć limit rezerwacji z analizą wrażliwości i opisać wyniki tak, żebyś umiał(a) je obronić.

Oferta dla studentówWyceń analizę

Bibliografia i dalsza literatura naukowa (APA 7)

  1. Bitran, G. R., & Gilbert, S. M. (1996). Managing hotel reservations with uncertain arrivals. Operations Research, 44(1), 35–49. https://doi.org/10.1287/opre.44.1.35
  2. Brown, L. D., Cai, T. T., & DasGupta, A. (2001). Interval estimation for a binomial proportion. Statistical Science, 16(2), 101–133. https://doi.org/10.1214/ss/1009213286
  3. Efron, B. (1979). Bootstrap methods: Another look at the jackknife. The Annals of Statistics, 7(1), 1–26. https://doi.org/10.1214/aos/1176344552 ● Otwarty dostęp
  4. Noone, B. M., & Lee, C. H. (2011). Hotel overbooking: The effect of overcompensation on customers’ reactions to denied service. Journal of Hospitality & Tourism Research, 35(3), 334–357. https://doi.org/10.1177/1096348010382238
  5. Rothstein, M. (1985). OR forum—OR and the airline overbooking problem. Operations Research, 33(2), 237–248. https://doi.org/10.1287/opre.33.2.237
  6. Williams, D. A. (1975). The analysis of binary responses from toxicological experiments involving reproduction and teratogenicity. Biometrics, 31(4), 949. https://doi.org/10.2307/2529820

Cytowania BibTeX

@article{bitran1996managing, author={Bitran, Gabriel R. and Gilbert, Stephen M.}, title={{Managing hotel reservations with uncertain arrivals}}, journal={Operations Research}, year={1996}, volume={44}, number={1}, pages={35--49}, doi={10.1287/opre.44.1.35}}
@article{brown2001interval, author={Brown, Lawrence D. and Cai, T. Tony and DasGupta, Anirban}, title={{Interval estimation for a binomial proportion}}, journal={Statistical Science}, year={2001}, volume={16}, number={2}, pages={101--133}, doi={10.1214/ss/1009213286}}
@article{efron1979bootstrap, author={Efron, Bradley}, title={{Bootstrap methods: Another look at the jackknife}}, journal={The Annals of Statistics}, year={1979}, volume={7}, number={1}, pages={1--26}, doi={10.1214/aos/1176344552}}
@article{noone2011hotel, author={Noone, Breffni M. and Lee, Chung Hun}, title={{Hotel overbooking: The effect of overcompensation on customers’ reactions to denied service}}, journal={Journal of Hospitality \& Tourism Research}, year={2011}, volume={35}, number={3}, pages={334--357}, doi={10.1177/1096348010382238}}
@article{rothstein1985or, author={Rothstein, Marvin}, title={{OR forum—OR and the airline overbooking problem}}, journal={Operations Research}, year={1985}, volume={33}, number={2}, pages={237--248}, doi={10.1287/opre.33.2.237}}
@article{williams1975analysis, author={Williams, D. A.}, title={{The analysis of binary responses from toxicological experiments involving reproduction and teratogenicity}}, journal={Biometrics}, year={1975}, volume={31}, number={4}, pages={949}, doi={10.2307/2529820}}
R