Batta Gábor (E9442E)

Félévközi házi feladat

Konténerrakodás optimalizációja

Házi feladatomban arra keresem a választ, hogy hogyan tervezzük és optimalizáljuk a konténeres szállítást és az egységrakomány képzés folyamatát. Modellünkben a szállítási feladat során egy raktárból, logisztikai központból kell az árut eljuttatni a megrendelő telephelyére. Az szállítandó áru dobozokba csomagolt, melyekről feltételezzük, hogy kis tűréssel azonos méretűek, sima felületűek és kellőképpen szilárdak, ahhoz, hogy halmazolni lehessen. Ennek - mint látni fogjuk - nagy jelentősége lesz a későbbiekben. Ismernünk kell továbbá a dobozok dimenzióit, azaz befoglaló méreteit és tömegét is. A szállítandó árú mennyisége, azaz a dobozok száma szintén adott.
	A feladatunk az, hogy képezzünk egységrakományokat, majd az egységrakományokat rakodjuk intermodális egységekbe - konténerekbe - mégpedig úgy, hogy ez optimális legyen. A feladat végeredményeként választ adhatunk arra a kérdésre, hogy hány konténer szállítására lesz szükségünk a megbízás elvégzésekor, illetve mindez milyen költségeket eredményez.
	Az optimalizációt két részre kell osztani, elsőként a raklap optimális rakodásmintáját kell meghatározni, majd a konténerbe rakodható egységrakományok számát, és dimenziót.

Az optimális rakodásminta meghatározása

Első feladatként a dobozokból egységrakományt kell képeznünk, hogy megkönnyítsük az áruk mozgatását, kezelését. Ehhez ISO szabvány szerinti Euro raklapot használunk. Az optimalizáláshoz a következő jelöléseket vezetjük be:

A, B, CC betűvel jelöljük az ISO Euro raklap méreteit (Hosszúság, Szélesség, Magasság), ezek milliméterben mérve a következők:

A =  1200

B = 800

CC = 144

a, b, c betűk a dobozok méreteit jelölik (milliméterben):

a =  184

b = 161

c = 151

Fontos kitérni további két, a gyakorlatból vett hallgatólagos megállapodásra is. Az első, hogy a raklapra a dobozokat az a és b élek által meghatározott lapjával pakoljuk. A másik, hogy az éleket csökkenő sorrend szerint nevezzük el, azaz a következő relációk fennállnak:

a > b > c

a > b > c

Ezeket a megkötéseket azért alkalmazzák, hogy az egységrakomány megfelelően stabil és tömör legyen.

(Subscript[n, Aa]^max) jelöli a raklap A oldalára a doboz a oldalával rakott dobozok maximális számát. Hasonlóan ehhez az (Subscript[n, Ab]^max) a raklap A oldalára a doboz b oldalával rakott dobozok maximális számát mutatja meg. Ugyanígy definiáljuk (Subscript[n, Bb]^max) és (Subscript[n, Ba]^max) értékeket is.
	Az (Subscript[n, Aa]) jelenti, a raklap A oldalára a doboz a oldalával ténylegesen rakott dobozok számát. Ugyanígy definiálunk (Subscript[n, Ab]), (Subscript[n, Ba]), (Subscript[n, Bb])értékeket is.

nAamax := IntegerPart[A/a]

nAbmax := IntegerPart[A/b]

nBamax := IntegerPart[B/a]

nBbmax := IntegerPart[B/b]

\(TableForm[{nAamax, \ nAbmax, \ nBamax, \ nBbmax}, 
      TableHeadings -> {{"nAamax:", "nAbmax:", "nBamax:", "nBbmax:"}}, TableAlignments -> Center]\)

Az optimalizálás során a következő korlátokat kell felállítani:

			1.	a ·(Subscript[n, Aa])+b·(Subscript[n, Ab])≤ A
			2.	a ·(Subscript[n, Ba])+b·(Subscript[n, Bb])≤ B

Az első feltételhez tartozó célfüggvény:

				a ·b·((Subscript[n, Aa])· (Subscript[n, Bb]^max)+(Subscript[n, Ab])· (Subscript[n, Ba]^max)) -> max

korlatok1 = {a×nAa + b×nAb ≤ A, 
        nAa ≥ 0, 
        nAb ≥ 0, (nAa | nAb | nBa | nBb) ∈  
          Integers}

F = 
      Maximize[{(nAa×nBbmax + nAb×nBamax), 
          korlatok1},  {nAa, nAb, nBa, nBb}]

A második feltételhez tartozó célfüggvény:

				a ·b·((Subscript[n, Bb])· (Subscript[n, Aa]^max)+(Subscript[n, Ba])· (Subscript[n, Ab]^max)) -> max

korlatok11 = {a×nBa + b×nBb ≤ B, 
        nAa ≥ 0, nAb ≥ 0, nBa ≥ 0, 
        nBb ≥ 0, (nAa | nAb | nBa | nBb) ∈  
          Integers}

F1 = 
      Maximize[{(nBb×nAamax + nBa×nAbmax), 
          korlatok11},  {nAa, nAb, nBa, nBb}]

Az eddigiek egy függvényben:

Rakminta[A_, B_, CC_, a_, b_, c_] := 
      Max[{Maximize[{(nAa×IntegerPart[B/b] + 
                    nAb×IntegerPart[B/a]), {a×nAa + 
                      b×nAb ≤ A, nAa ≥ 0, 
                  nAb ≥ 
                    0, (nAa | nAb | nBa | nBb) ∈  
                    Integers}},  {nAa, nAb, nBa, 
                nBb}][[1]], Maximize[{(nBb×
                      IntegerPart[A/a] + 
                    nBa×IntegerPart[A/b]), {a×nBa + 
                      b×nBb ≤ B, nAa ≥ 0, 
                  nAb ≥ 0, nBa ≥ 0, 
                  nBb ≥ 
                    0, (nAa | nAb | nBa | nBb) ∈  
                    Integers}},  {nAa, nAb, nBa, 
                nBb}][[1]]}]

Rakminta[1200, 800, 144, 184, 161, 151]

Ki kell választani a két megközelítés (A vagy B oldalról történő pakolás) közül azt, amelyik segítségével több dobozt lehet a raklapra helyezni:

ndobozperreteg = Max[F[[1]], F1[[1]]]

A konténermegrakás optimalizálása

Az optimális rakminta ismeretében, tudjuk, hogy az egységrakomány egy rétegében hány dobozt tudunk elhelyezni. Ismerjük a szállítandó dobozok súlyát, jelölve az (Subscript[m, doboz])-t is (kilógrammban):

mdoboz = 3

Így már ki tudjuk számolni egy réteg teljes tömegét:

		(Subscript[m, r])éteg = 
        (Subscript[n, doboz/réteg])·(Subscript[m, doboz])

mreteg = ndobozperreteg×mdoboz

Az egységrakomány bruttó tömegének is van egy maximuma, mégpedig egy tonna. Ennek szintén gyakorlati okai vannak, ugyanis a magának a raklapnak - amely általában fából készül - és a raklapokat mozgató targoncáknak is ez a tömeg a gyakorlatban használt maximális teherbírása.

mmaxer = 1000

Természetesen ismerni kell a raklap saját tömegét is, ami (kilógrammban):

mraklap = 25

A súlykorlát miatti rétegszám maximuma a következő:

nretegsuly = IntegerPart[(mmaxer - mraklap)/mreteg]

A súlyhatáron kívül egy másik korlátozással is számolni kell az egységrakomány összeállítása során. Az egységrakomány ne legyen nagyobb 1,5 méternél, természetesen a raklap magasságát (CC) is hozzászámolva. Ennek oka, a stabilitásra és a munkabiztonságra vezethető vissza. Körülbelül egy méter az a magasság, ami felett a targonca vezetője még felemelt egységrakományt mozgatva is kilát, így biztonságosan tud a teherrel közlekedni. A korlát tehát (milliméterben):

hmaxer = 1500

A magasságkorlát miatti rétegszám maximuma:

nretegmagassag = IntegerPart[(hmaxer - CC)/c]

Ki kell választanunk a kisebbik értéket, ez lesz az egységrakomány maximális rétegszáma:

nretegermax = Min[nretegsuly,  nretegmagassag]

Még egyszer fontos megjegyezni, hogy ez a rétegszám az egységrakományt alkotó dobozok rétegeinek maximális száma. Valószínűleg, ennél kevesebb rétegű egységrakományokat fogunk használni, mivel az optimalizáció a konténer megrakásáról szól. Lehet, hogy egyel kevesebb rétegű egységrakomány alkalmazásakor egymás felett több fér be egy konténerbe, így egy konténerben több dobozt is szállíthatunk. Azt is le kell szögezni, hogy csak azonos rétegszámú egységrakományokat képezhetünk. Az egységrakomány rétegszámtól függő bruttó súlyát és magasságát a következő képen számolhatjuk:

		(Subscript[m, ER]) = 
        (Subscript[n, r])éteg·(Subscript[m, r])éteg + (Subscript[m, raklap])
		(Subscript[h, ER]) = (Subscript[n, r])éteg·c + CC

Így, már ismert az egységrakomány minden dimenziójának számítási menete. Az egységrakományok szállítása konténerben történik. A konténeres szállításnak számtalan előnye van. Többek között, nem kell eszközváltások átrakodni az árut, az áru védve van a környezetétől, illetve a környezet is az árutól. A konténereke ezen kívül halmazolhatók is. ISO szabványban van rögzítve minden fontos paraméterük. Alapvetően három típus létezik, az 1C, 1B és az 1A, melyek sorrendben 20, 30, és 40 láb hosszúságúak. Az 1C konténer TEU (Twenty-feet Equivalent Unit) néven is ismert, főleg konténerszállító hajók befogadóképességét és konténerterminálok forgalmát jellemzik vele. A konténer belső méreteit három betűvel jelöljük. H a magassága, L a hossza és W a szélessége. 1C konténer esetében ezek az értékek (milliméterben):

H = 2197

L = 5867

W = 2330

A fenti méretek segítségével könnyű belátni, hogy egy 1C konténerbe egy rétegben 11 Euro raklap helyezhető le. Ez az érték 1B esetében 18, 1A-nál 23 db. Ebben a modellben 1C konténerek rakodását optimalizáljuk!
	A konténer rakodásakor, sajnos nem használhatjuk ki a teljes belső magasságot, mert kell tartani egy biztonsági rést, azért, hogy a targonca kezelője a legfelső egységrakományt is a helyére tudja illeszteni. E rés gyakorlati értéke (milliméterben):

res = 100

Adott magasságú egységrakomány melletti szintszámot (Subscript[n, szint])-tel jelöljük.

A konténerek rakodásának határt szab a rakott konténer maximális bruttó tömege is. Ennek nagysága 1C konténer esetén (kilógrammban):

mcontbruttomax = 20320

Ebből az össztömegből az 1C konténer saját súlya (kilógrammban):

mcont = 2150

A konténer belső magasságával kapcsolatos megszorítások értelmében megállapítható a konténerben lévő egységrakományok összes száma. Ezt (Subscript[n, ER, cont]) értékkel jelöljük.

Most már minden fontos összetevőt tisztáztunk, így fel tudjuk írni a konténerrakodás optimalizálásának korlátait és a célfüggvényt is:

A korlátozó tényezők a következőek lesznek:

	Az egységrakomány összsúlyára vonatkozó megkötés:		1.	\(TraditionalForm\`m\_ER = \(\(m\_réteg\)\(·\)\)\)(Subscript[n, r])éteg+(Subscript[m, raklap])≤ (Subscript[m, ER]^max)
	A konténer összsúlyára vonatkozó megkötés:			2.	\(TraditionalForm\`m\_\(cont, brutto\) = \(\(m\_ER\)\(·\)\)\)(Subscript[n, ER, cont])+(Subscript[m, cont])≤ (Subscript[m, cont, brutto]^max)
	Az egységrakomány bruttó magasságára vonatkozóan:		3.	(Subscript[h, ER]) = (Subscript[n, r])éteg·c + CC≤(Subscript[h, ER]^max)
	A konténer belső magasságára vonatkozóan:			4.	(Subscript[h, ER])·(Subscript[n, szint]) + Rés≤ H
	A konténerben egy szinten elhelyezhető raklapok száma miatt:	5. 	((Subscript[n, ER, cont])/(Subscript[n, szint])) ≤ 11

korlatok2 = {mreteg×nreteg + mraklap ≤ 
          mmaxer,  (mreteg×nreteg + mraklap)×nercont + 
            mcont ≤ mcontbruttomax,  
        nreteg×c + CC ≤ 
          hmaxer,  (nreteg×c + CC)×nszint + 
            res ≤ H, nercont ≤ 11*nszint, 
        nszint ≥ 0 , nreteg ≥ 0,  
        nercont ≥ 0, {nszint,  nreteg,  nercont} ∈ 
          Integers}

A maximalizálandó célfüggvény nem is lehet más, mint az egy konténerben lévő dobozok maximális száma:
	
									
										N=(Subscript[n, doboz/réteg])·
        (Subscript[n, r])éteg·(Subscript[n, ER, cont])->max

Opt = 
      NMaximize[{nreteg×nercont×ndobozperreteg, 
          korlatok2}, {nszint, nercont, nreteg}]

Az eddigiek egy függvényben:

Kontener[A_, B_, CC_, a_, b_, c_, mdoboz_, mmaxer_, mraklap_, hmaxer_, 
        H_, L_, W_, erksz_, res_, mcontbruttomax_, mcont_] := 
      NMaximize[{nreteg×nercont×
            Max[{Maximize[{(nAa×IntegerPart[B/b] + 
                          nAb×IntegerPart[B/a]), {a×nAa + 
                            b×nAb ≤ A, 
                        nAa ≥ 0, 
                        nAb ≥ 
                          0, (nAa | nAb | nBa | nBb) ∈  
                          Integers}},  {nAa, nAb, nBa, 
                      nBb}][[1]], Maximize[{(nBb×
                            IntegerPart[A/a] + 
                          nBa×IntegerPart[A/b]), {a×nBa + 
                            b×nBb ≤ B, 
                        nAa ≥ 0, nAb ≥ 0, 
                        nBa ≥ 0, 
                        nBb ≥ 
                          0, (nAa | nAb | nBa | nBb) ∈  
                          Integers}},  {nAa, nAb, nBa, 
                      nBb}][[1]]}], {Max[{Maximize[{(nAa×
                                  IntegerPart[B/b] + 
                                nAb×IntegerPart[B/a]), {a×
                                    nAa + b×nAb ≤ A, 
                              nAa ≥ 0, 
                              nAb ≥ 
                                0, (nAa | nAb | nBa | nBb) ∈  
                                Integers}},  {nAa, nAb, nBa, 
                            nBb}][[1]], Maximize[{(nBb×
                                  IntegerPart[A/a] + 
                                nBa×IntegerPart[A/b]), {a×
                                    nBa + b×nBb ≤ B, 
                              nAa ≥ 0, nAb ≥ 0, 
                              nBa ≥ 0, 
                              nBb ≥ 
                                0, (nAa | nAb | nBa | nBb) ∈  
                                Integers}},  {nAa, nAb, nBa, 
                            nBb}][[1]]}]×mdoboz×nreteg + 
                mraklap ≤ 
              mmaxer,  (Max[{Maximize[{(nAa×IntegerPart[B/b] + 
                                      nAb×IntegerPart[
                                        B/a]), {a×nAa + 
                                        b×nAb ≤ A, 
                                    nAa ≥ 0, 
                                    nAb ≥ 
                                      0, (nAa | nAb | nBa | 
                                        nBb) ∈  
                                      Integers}},  {nAa, nAb, nBa, 
                                  nBb}][[1]], Maximize[{(nBb×
                                        IntegerPart[A/a] + 
                                      nBa×IntegerPart[
                                        A/b]), {a×nBa + 
                                        b×nBb ≤ B, 
                                    nAa ≥ 0, 
                                    nAb ≥ 0, 
                                    nBa ≥ 0, 
                                    nBb ≥ 
                                      0, (nAa | nAb | nBa | 
                                        nBb) ∈  
                                      Integers}},  {nAa, nAb, nBa, 
                                  nBb}][[1]]}]×mdoboz×
                        nreteg + mraklap)×nercont + 
                mcont ≤ mcontbruttomax,  
            nreteg×c + CC ≤ 
              hmaxer,  (nreteg×c + CC)×nszint + 
                res ≤ H, nercont ≤ erksz*nszint, 
            nszint ≥ 0 , nreteg ≥ 0,  
            nercont ≥ 
              0, {nszint,  nreteg,  nercont} ∈ 
              Integers}}, {nszint, nercont, nreteg}]

Opt = 
      Kontener[1200, 800, 144, 184, 161, 151, 5, 1000, 25, 1500, 2197, 5867, 
        2330, 11, 97, 20320, 2150]

Az optimális megoldás tehát ebben az esetben adódik:

\(TableForm[{Opt[\([1]\)], \ Opt[\([2, 2, 2]\)], \ Opt[\([2, 1, 2]\)], \ 
        Opt[\([2, 3, 2]\)]}, \ 
      TableHeadings -> {{"Konténerbe rakodható dobozok összes száma:", "Az egységrakomány rétegeinek száma:", "A konténerbe rakodható egységrakományok száma:", "Rakodási szintek száma:"}}, 
      TableAlignments -> Center]\)

Ezután ellenőrizhetjük, hogy betartottunk-e minden, a magasságra, vagy teherbírásra vonatkozó összes korlátozást:

\(TableForm[{{\(Opt[\([1]\)]/mdoboz\)/nercont×Opt[\([2, 2, 2]\)] + 
            mraklap, "≤", mmaxer, \ 
          If[ToString[
                mreteg×Opt[\([2, 2, 2]\)] + mraklap ≤ 
                  mmaxer] == "True", \ "MEGFELEL", \ "TÚLSÚLYOS!"]}, {\((mreteg×
                    Opt[\([2, 2, 2]\)] + mraklap)\)×
              Opt[\([2, 1, 2]\)] + mcont, "≤", mcontbruttomax, 
          If[ToString[\((mreteg×Opt[\([2, 2, 2]\)] + mraklap)\)×
                      Opt[\([2, 1, 2]\)] + mcont ≤ 
                  mcontbruttomax] == "True", \ "MEGFELEL", \ "TÚLSÚLYOS!"]}, \ {Opt[\([2, 2, 2]\)]×
              c + CC, "≤", hmaxer, 
          If[ToString[
                Opt[\([2, 2, 2]\)]×c + CC ≤ 
                  hmaxer] == "True", \ "MEGFELEL", \ "TÚL MAGAS!"]}, \ {\((Opt[\([2, 2, 2]\)]×c + 
                  CC)\)×Opt[\([2, 3, 2]\)] + res, "≤", 
          H, If[ToString[\((Opt[\([2, 2, 2]\)]×c + CC)\)×
                      Opt[\([2, 3, 2]\)] + res ≤ 
                  H] == "True", \ "MEGFELEL", \ "TÚL MAGAS!"]}, \ {Opt[\([2, 1, 2]\)]/Opt[\([2, 3, 2]\)], "≤", 
          11, If[ToString[
                Opt[\([2, 1, 2]\)]/Opt[\([2, 3, 2]\)] ≤ 
                  11] == "True", \ "MEGFELEL", \ "A RAKMINTÁNAK NEM FELEL MEG!"]}}, 
      TableHeadings -> {{"Egységrakomány súlya (kg):", "Konténer összúlya (kg):", "Egységrakomány magassága (mm):", "Használt belmagasság (mm):", "Egy szintben lévő raklapok száma:"}, {"SZÁMÍTOTT ÉRTÉKEK", "", "KORLÁTOK"}}, TableAlignments -> Center]\)

A kiszámított eredmények nagyon gyanúsak! Valószínű, hogy egyes esetekben az NMaximize függvény, nem is az optimális megoldást adja! Erre az egy szintben történő rakodásból következtethetünk! Kipróbálva különböző rétegszámokra (1-től a maximálisig) a gyanu be is igazolódhat. Ennekellenőrzésére:

For[i = 1, 
      i ≤ 
        nretegermax, i++, 
korlatok2 = {mreteg×
                nreteg + mraklap ≤ 
            mmaxer,  (mreteg×nreteg + mraklap)×nercont + 
              mcont ≤ mcontbruttomax,  
          nreteg×c + CC ≤ 
            hmaxer,  (nreteg×c + CC)×nszint + 
              res ≤ H, nercont ≤ 11*nszint, 
          nszint >= 0 , nreteg == i,  
          nercont ≥ 0, {nszint,  nreteg,  nercont} ∈ 
            Integers}; 
Opt = 
        NMaximize[{nreteg×nercont×ndobozperreteg, 
            korlatok2}, {nszint, nercont, nreteg}]; 
Print[
        Opt]]

Látható, hogy öt réteget hasznáklva jóval több doboz rakodható, így most rögzítsük a rétegszámot 5-ben, és lefutatjuk újra az optimalizációt!

korlatok2 = {mreteg×nreteg + mraklap ≤ 
          mmaxer,  (mreteg×nreteg + mraklap)×nercont + 
            mcont ≤ mcontbruttomax,  
        nreteg×c + CC ≤ 
          hmaxer,  (nreteg×c + CC)×nszint + 
            res ≤ H, nercont ≤ 11*nszint, 
        nszint >= 0 , nreteg == 5,  
        nercont ≥ 0, {nszint,  nreteg,  nercont} ∈ 
          Integers}

A maximalizálandó célfüggvény nem is lehet más, mint az egy konténerben lévő dobozok maximális száma:
	
									
										N=(Subscript[n, doboz/réteg])·
        (Subscript[n, r])éteg·(Subscript[n, ER, cont])->max

Opt = 
      NMaximize[{nreteg×nercont×ndobozperreteg, 
          korlatok2}, {nszint, nercont, nreteg}]

Most már valóban az optimális megoldás adódik:

\(TableForm[{Opt[\([1]\)], \ Opt[\([2, 2, 2]\)], \ Opt[\([2, 1, 2]\)], \ 
        Opt[\([2, 3, 2]\)]}, \ 
      TableHeadings -> {{"Konténerbe rakodható dobozok összes száma:", "Az egységrakomány rétegeinek száma:", "A konténerbe rakodható egységrakományok száma:", "Rakodási szintek száma:"}}, 
      TableAlignments -> Center]\)

Ezután ellenőrizhetjük, hogy betartottunk-e minden, a magasságra, vagy teherbírásra vonatkozó összes korlátozást:

\(TableForm[{{mreteg×Opt[\([2, 2, 2]\)] + 
            mraklap, "≤", mmaxer, \ 
          If[ToString[
                mreteg×Opt[\([2, 2, 2]\)] + mraklap ≤ 
                  mmaxer] == "True", \ "MEGFELEL", \ "TÚLSÚLYOS!"]}, {\((mreteg×
                    Opt[\([2, 2, 2]\)] + mraklap)\)×
              Opt[\([2, 1, 2]\)] + mcont, "≤", mcontbruttomax, 
          If[ToString[\((mreteg×Opt[\([2, 2, 2]\)] + mraklap)\)×
                      Opt[\([2, 1, 2]\)] + mcont ≤ 
                  mcontbruttomax] == "True", \ "MEGFELEL", \ "TÚLSÚLYOS!"]}, \ {Opt[\([2, 2, 2]\)]×
              c + CC, "≤", hmaxer, 
          If[ToString[
                Opt[\([2, 2, 2]\)]×c + CC ≤ 
                  hmaxer] == "True", \ "MEGFELEL", \ "TÚL MAGAS!"]}, \ {\((Opt[\([2, 2, 2]\)]×c + 
                  CC)\)×Opt[\([2, 3, 2]\)] + res, "≤", 
          H, If[ToString[\((Opt[\([2, 2, 2]\)]×c + CC)\)×
                      Opt[\([2, 3, 2]\)] + res ≤ 
                  H] == "True", \ "MEGFELEL", \ "TÚL MAGAS!"]}, \ {Opt[\([2, 1, 2]\)]/Opt[\([2, 3, 2]\)], "≤", 
          11, If[ToString[
                Opt[\([2, 1, 2]\)]/Opt[\([2, 3, 2]\)] ≤ 
                  11] == "True", \ "MEGFELEL", \ "A RAKMINTÁNAK NEM FELEL MEG!"]}}, 
      TableHeadings -> {{"Egységrakomány súlya (kg):", "Konténer összúlya (kg):", "Egységrakomány magassága (mm):", "Használt belmagasság (mm):", "Egy szintben lévő raklapok száma:"}, {"SZÁMÍTOTT ÉRTÉKEK", "", "KORLÁTOK"}}, TableAlignments -> Center]\)

A Mathematica segítségével, könnyen újra lehet számolni a megoldást más méretű vagy tömegű dobozokkal, nagyobb biztonsági légréssel, kisebb teherbírású targonca esetén. Az egyik legjobb példa a biztonsági légrés (res) 3 (!) miliméterrel való csökkentése (ügyesebb targoncavezetőket alkalmazunk...). Akkor, optimális megoldás esetén már 3696 dobozt rakodhatunk egy konténerbe, ami kereken +20% -os (!) változást jelent, így a gyakorlatban ötödével kevesebb konténert kell használni, dobozok tízezreinek elszállításakor. Evvel a kis változtatással is rengeteg kiadás megspórolható!