Pallet Loading Problem - Ensiwiki

Pallet Loading Problem
Gabriel MATTOS LANGELOH
13 Mai 2015
Table des matières
1 Introduction
1.1 Contexte de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2
2
2 L’algorithme en 2-blocs
2.1 Fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Implémentation et expériences numériques . . . . . . . . . . . . . . . . . . . . . .
2.3 Qualité des solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2
5
6
3 Heuristiques plus efficaces: 5-blocs et L-blocs
3.1 L’heuristique en 5-blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 L’heuristique en L-blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Expériences numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
8
8
8
4 Conclusion
4.1 Résumé du travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Bilan du module IRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
9
9
10
A Instances avec grand écart entre la solution 2-bloc et 5-bloc
10
B Exemples d’instances où L-blocs domine 5-blocs
12
1
1
1.1
Introduction
Contexte de travail
Ce travail a été réalisé dans le cadre du module IRL (Introduction à la Recherche en Laboratoire)
au laboratoire G-SCOP. Le sujet a été proposé et encadré par Vincent Jost, chercheur dans GSCOP. Un étudiant en Master 2 en Recherche Opérationnelle, Léo Planche, a travaillé sur le
même sujet pendant ce semestre, mais pas toujours sur les mêmes questions.
1.2
Le problème
Le Pallet Loading Problem (dans la suite appelé PLP) est un problème d’optimisation qui consiste
à déterminer combien de petits rectangles égales de cotés entiers (l, w) peuvent être placés dans un
grand rectangle de cotés entiers (L, W ), sans superposition et sachant que les petits rectangles
ne peuvent être placés que verticalement ou horizontalement par rapport au grand rectangle.
Ainsi, une instance de PLP est définie par 4 entiers (L, W, l, w).
Dans quelques cas, le problème est facile à résoudre (si on a, par exemple, l = w). Quand
pgcd(l, w) = h, avec h 6= 1, l’instance peut être réduite à (bL/hc, bW/hc, l/h, w/h) d’où on
conclut que les instances intéressantes à analyser ont toutes pgcd(l, w) = 1. Modèles pour
résoudre ce problème exactement avec la Programmation Linéaire en Nombres Entiers (PLNE)
peuvent être écrits, mais la complexité de la résolution est trop haute pour que cette méthode
soit utile pour les instances de grande taille. Toutefois, la PLNE peut être utilisé pour obtenir des
bornes supérieures sur la solution optimale des instances, et alors pour prouver que des solutions
trouvés par des heuristiques sont optimales. Il y a encore d’autres bornes utiles, souvent plus
faciles à calculer, comme celle de [1]. La complexité du problème est encore ouverte. Quelques
auteurs, comme [4] ont affirmé sans preuve qu’il est NP complet, tandis qu’autres comme [8] ce
montrent sceptiques, parce que chaque instance peut être codé sur 4 entiers, et les problèmes
NP complets classiques ont ses entrées définies sur une quantité non-bornée de nombres. Ainsi,
la recherche sur le PLP est principalement concentrée en trouver des heuristiques efficaces pour
résoudre des grandes instances et aussi en montrer que ces heuristiques ont des bonnes propriétés
théoriques.
La plupart des heuristiques pour le PLP est basée sur la structure des solutions, c’est-à-dire, la
façon que les petits rectangles sont organisés dans le grand rectangle. Une première idée consiste à
diviser le grand rectangle en deux sous-rectangles récursivement, résoudre ces sous-instances (par
exemple, par programmation dynamique) et après composer la solution de l’instance originale.
Cet algorithme est appelé 2-blocs ou guillotine. Autres algorithmes généralisent cette idée,
comme l’algorithme en 5-blocs et le L-blocs. Ce dernier a la particularité d’avoir toujours trouvé
la solution optimale pour les instances testées. Ainsi, c’est conjecturé que l’algorithme en L-blocs
résout optimalement le PLP. Ces algorithmes seront explorés en plus de détail dans ce rapport,
en montrant des résultats théoriques connus et en faisant une analyse des expériences numériques
qu’on a fait.
2
2.1
L’algorithme en 2-blocs
Fonctionnement
Si on ajoute au PLP la restriction de que les petits rectangles doivent être placés dans le grand
rectangle par coupes guillotine, c’est-à-dire coupes qui divisent un rectangle (L, W ) en deux parallèlement à un de ses cotés, le problème est appelé Guillotine Pallet Loading Problem et, comme
2
montré par [9], peut être résolu en temps polynomial O(θlog22 w), avec θ = max{L, W, l, W } et
supposant l < w. Cette dernière hypothèse ne pose pas un problème, parce que si l = w le PLP
est trivial à résoudre, et une instance (L, W, l, w) a la même solution optimale que (L, W, w, l).
Le même algorithme peut être utilisé comme heuristique pour résoudre efficacement des
instances générales du PLP, mais les solutions obtenues ne sont pas forcement optimales, comme
montre la figure 1.
Figure 1: Instance (90, 90, 7, 8) résolue par l’algorithme en 2-blocs à gauche et par 5-blocs (une
solution optimale) à droite. Le 2-blocs a chargé 138 petits rectangles dans le grand, tandis que
le 5-blocs a chargé 144.
On présent ici succinctement l’algorithme 2-blocs proposé par [9], adapté pour renvoyer le
nombre de rectangles chargés en plus de l’aire non-utilisé (waste). On suppose toujours l <
w, pgcd(l, w) = 1. Définissons un l-strip comme un coup guillotine (vertical ou horizontal) de
largeur l remplit avec bL/wc petits rectangles, où L est égal à W si le l-strip est vertical ou L si
le l-strip est horizontal. Posons
E0 (y) = (W − ly)
mod w
(1)
E1 (y) = (L − ly)
mod w
(2)
Alors lE0 (y) et lE1 (y) donnent le waste d’un l-strip vertical qui repose sur y l-strips horizontales et d’un l-strip horizontal reposant sur y l-strips verticales, respectivement. On pose
n = bL/lc, m = bW/lc. Un bloc de l-strips est simplement une suite de l-strips de même orientation. On définit un block-l-pattern par deux entiers r, s qui correspondent aux quantités de
blocs de l-strips verticales et horizontales, respectivement, avec des variables v1 , ..., vr donnant les
tailles des blocs verticales et g1 , ..., gs les tailles des blocs horizontales, en plus de r + s booleans
x
si un bloc donné est vertical ou horizontal. On a encore les conditions
Pdisent
P1 ,r ..., xr+s qui
s
g
=
m. Ainsi un block-l-pattern est simplement une solution (optimale ou
v
=
n,
i=1 i
i=1 i
pas) du PLP guillotine.
Comme l’objectif est minimiser le waste, on pose (i, j) comme l’ensemble des block-l-patterns
avec i blocs verticales et j blocs horizontales. Soit H(i, j) le waste minimal pour (i, j). Alors on
écrit la récurrence
3
X
X
j
i
H(i, j) = min H(i − 1, j) + vi E0
gt , H(i, j − 1) + gi E1
vt
t=1
t=1
pour i = 1, ..., r, j = 1, ..., s
H(0, 0) = 0
H(i, 0) = E0 (0)
i
X
vt pour i = 1, ..., r
t=1
H(0, j) = E1 (0)
j
X
gt pour j = 1, ..., s
t=1
Intuitivement, le min dans la récurrence représente la choix entre avoir le boolean xi+j verticale ou horizontale. Cette relation de récurrence peut être résolue par programmation dynamique.
On peut aussi poser
W − ly
(3)
B0 (y) =
w
L − ly
B1 (y) =
(4)
w
les quantités de petits rectangles dans un l-strip vertical ou horizontal respectivement, au
lieu du waste comme fait précédemment. On peut substituer dans la récurrence le min par un
max et les fonctions E0 , E1 par B0 , B1 pour avoir une relation qui donne le nombre de blocs de
la solution optimale au lieu du waste.
Pour utiliser la programmation dynamique pour résoudre la relation de récurrence donnée, il
faut encore avoir un algorithme pour trouver les valeurs v1 , ..., vr et g1 , ..., gs . On peut obtenir
ces valeurs en calculant les points qui minimisent respectivement E1 et E0 plus petits que σ1− et
σ0− .
En pratique, au lieu d’appliquer la récurrence à l’instance (L, W, l, w) originale du PLP, on
peut la diviser en 3 sous-problèmes, parmi lesquels 2 seront résolus par programmation dynamique.
Soient A0 = {σ : σ = argmin0≤y≤m E0 (y)} et A1 = {σ : σ = argmin0≤y≤n E1 (y)}. On pose
σ0− = min A0 , σ0+ = max A0 , σ1− = min A1 , σ1+ = max A1 . L’algorithme commence par diviser
l’instance original en trois parties:
1. (L, W ) \ (L − σ1− l, W − σ0− l)
2. (L − σ1− l, W − σ0− l) \ (L − σ1+ l, W − lσ0+ l)
3. (L − σ1+ l, W − lσ0+ l)
La première et la troisième partie sont ensuite résolues par programmation dynamique, tandis
que la deuxième partie est résolue en temps constant en choisissant σ0+ − σ0− l-strips verticales
et σ1+ − σ1− horizontales.
Une caractéristique intéressante de l’algorithme en 2-blocs décrit est qu’il peut être parallélisé
de plusieurs façons. Comme l’instance originale est divisée en 3 sous-problèmes indépendants,
ces trois problèmes peuvent être résolus en parallèle. En pratique, comme le deuxième sousproblème peut être résolu en temps constant (et très petit), c’est plus intéressant de résoudre
4
que les sous-problèmes 1 et 3 en parallèle. On peut aussi paralléliser l’algorithme de programmation dynamique lui même, en observant que, si on écrit un graphe d’appels pour la relation de
récurrence H, H(i − 1, j) est indépendant de H(i, j − 1), et on peut dire le même pour n’importe
quels deux éléments d’une même anti-diagonal de la matrice indexée par (i, j).
2.2
Implémentation et expériences numériques
L’algorithme en 2-blocs comme résumé dans la section précédente a été implémenté en Haskell
pour obtenir une bonne performance et au même temps écrire du code en haut niveau grace à
la programmation fonctionnelle pure. Le code a été optimisé par le compilateur au niveau maximum (O2), et les tests ont été faits sur une machine Intel Core i5-3337U @ 1.8GHz. Les sources
et fichiers de test peuvent être téléchargés sur https://ensiwiki.ensimag.fr/index.php/
Gabriel_Mattos_Langeloh_(avec_Vincent_Jost)_:_Un_casse-t%C3%AAte_qui_vaut_cher:_The_
Pallet_Loading_Problem.
Les instances utilisées pour les tests sont les mêmes utilisées dans la littérature, par exemple
dans [2]. Ces instances sont séparées en 5 fichiers comme suit.
• Cover IA: 8274 instances avec 1 ≤
L
W
• Cover IIA: 41831 instances avec 1 ≤
• Cover IB: 7827 instances avec 1 ≤
L
W
• Cover IIB: 40609 instances avec 1 ≤
• Cover IIIB: 98016 instances avec 1 ≤
≤ 3, 1 ≤
L
W
L
W
≤ 4, 1 ≤
≤ 2.2, 1 ≤
≤ 2, 1 ≤
L
W
l
w
l
w
≤ 2, 1 ≤
≤ 2, 1 ≤
l
w
LW
lw
≤ 4, 51 ≤
l
w
≤ 51
≤ 4, 51 ≤
≤ 4, 1 ≤
l
w
LW
lw
LW
lw
≤ 101
≤ 51
LW
lw
≤ 4, 101 ≤
≤ 101
LW
lw
≤ 151
Chaque instance dans les trois dernières ensembles est l’instance de taille minimale d’une classe
d’équivalence avec infinies instances, comme définie par [6]. Dans le fichier Cover IIIB, il y a des
instances dont l’optimalité de la meilleure solution connue n’a pas été prouvé. Dans ces cas, on
a considéré que la meilleure solution connue est optimale.
Fichier
CoverIA
CoverIIA
CoverIB
CoverIIB
CoverIIIB
Temps d’exécution (s)
0.442s
2.534s
0.418s
2.235s
7.145s
Optimales
6102
26081
5824
25422
53909
Pourcentage
74.47%
62.34%
74.40%
62.60%
55.00%
Écart max
4
5
4
5
6
Figure 2: Résultats obtenus pour l’algorithme en 2-blocs sur les fichiers de test. La colonne
Optimales montre le nombre d’instances pour lesquelles l’algorithme en 2-blocs a trouvé la solution optimale, la colonne Pourcentage montre la proportion de ces instances par rapport au
nombre d’instances dans le fichier et la colonne Écart max représente la distance maximale entre
le nombre de rectangles de la solution trouvé et le celui de la solution optimale.
Le tableau dans la figure 2 montre les résultats obtenus par cette implémentation. On peut
observer que l’algorithme résout les instances rapidement, même celles de grande taille, réussissant à obtenir des résultats pour toutes les instances du CoverIIIB en quelques secondes. Pour
effet de comparaison, les heuristiques plus élaborées, comme 5-blocs et L-blocs prennent quelques
heures pour résoudre le CoverIIIB sur la même machine. L’heuristique en L-blocs, en particulier, prend quelques minutes pour résoudre les instances plus difficiles. On observe aussi que le
5
pourcentage d’instances dont la solution optimale n’a pas été trouvée par cette heuristique croit
avec la taille des instances. Par contre, malgré la croissance aussi de l’écart maximum entre le
nombre de rectangles de la solution trouvée et celui de l’optimale, on observe qu’il n’y a que
8 instances avec écart maximum 6, par exemple, entre les presque 200000 instances testées, et
qu’en plus l’écart semble être toujours petit par rapport au nombre de rectangles trouvé. Ainsi,
on peut penser que, pour des applications pratiques où la vitesse de réponse est importante, cette
heuristique peut être utile.
La croissance de l’écart entre les solutions trouvées et optimales suggère encore la question:
est-ce que cet écart est borné? En particulier, est-ce qu’il y existe une borne pour l’écart entre
2-blocs et 5-blocs, ou 2-blocs et L-blocs? Si la réponse de la première question est oui, alors il
y a une heuristique de temps polynomial pour le PLP qui produit des solutions avec la garantie
qu’elles ne sont pas trop mauvaises, dans un sens précis en connaissant la borne.
2.3
Qualité des solutions
Définissons une instance où le grand rectangle est un carré de coté S par une triple (S, l, w), le
nombre de rectangles de la solution obtenue par l’algorithme en 2-blocs par Sol2 (S, l, w) et celui
de la solution par 5-blocs par Sol5 (S, l, w). On dénote la solution optimale par Solopt (S, l, w).
On utilise aussi une notation similaire pour les instances (L, W, l, w). On a le résultat suivant
(une explication intuitive est donnée par les figures de l’annexe A):
Théorème 1. L’écart Solopt (L, W, l, w) − Sol2 (L, W, l, w) n’est pas borné.
Démonstration. Soit k > 2 un entier positif. Prenons une instance (S, l, w) avec l = 2, w = 2k − 1
et S = 2(w − 1). Il existe une solution 5-blocs composée de 4 blocs mono-orientés au tour
d’un trou telle que chaque bloc mono-orienté contient exactement w−1
2 − 1 petits rectangles car
w−1
w−1
l( w−1
2 − 1) + w = 2( 2 − 1) + w = 2w − 3 = S − 1. Alors, Sol5 (S, l, w) ≥ 4( 2 − 1) = 2w − 6.
Dans la suite, on déduit la solution 2-blocs pour l’instance (S, l, w). Comme elle est carré,
les fonctions donnant le waste d’une l-strip E0 et E1 sont égales partout, et seront dénotées par
E(y) = S − ly mod w. On observe que cette fonction est périodique de période w, c’est-à-dire
E(y + tw) = E(y) et que, pour y1 , y2 ≤ w, y1 6= y2 , on a E(y1 ) 6= E(y2 ). Alors cette fonction est
une bijection de {0, ..., w − 1} vers lui même, d’où on conclut qu’elle a exactement un zéro sur
cet ensemble là.
Soient A = {σ : σ = argmin0≤y≤n E(y)}, où n = Sl = w − 1, σ − = min A et σ + = max A.
Comme E a un seul zéro pour 0 ≤ y ≤ w − 1, alors σ − = σ + . En plus,
E(w − 1) = S − l(w − 1)
mod w
= 2(w − 1) − 2(w − 1)
mod w
=0
d’où σ − = σ + = w − 1.
Ainsi S − lσ − = S − lσ + = 0 et le seul sous-problème de l’algorithme 2-blocs à résoudre est
le premier.
Pour calculer les tailles v1 , ..., vr et g1 , ..., gs des block-l-patterns nécessaires pour appliquer la
programmation dynamique, on utilise l’algorithme Partition déduit par [9]. Comme E(y) = S−ly
mod w, et σ − = w −
utilise P artition(α0 = S mod w, α = −l mod w, β = w, ζ = w − 1),
1, on
, y2 = w − 1. D’après le Théorème 3 de [9], il y existe une solution
qui retourne y1 = w−2
2
optimale pour le sous-problème 1 avec v1 = g1 = y1 et v2 = g2 = y2 − y1 . Pour trouver
Sol2 (S, l, w) on calcule Bl(2, 2) par la récurrence
6
X
X
j
i
Bl(i, j) = min Bl(i − 1, j) + vi B
gt , Bl(i, j − 1) + gi B
vt
t=1
t=1
pour i = 1, ..., r, j = 1, ..., s
Bl(0, 0) = 0
Bl(i, 0) = B(0)
i
X
vt pour i = 1, ..., r
t=1
Bl(0, j) = B(0)
j
X
gt pour j = 1, ..., s
t=1
où B(y) =
j
S−ly
w
k
. Comme vi = gi ∀i ≤ 2, on a
Bl(2, 2) = Bl(1, 2) + v2 B(g1 + g2 )
= Bl(0, 2) + v1 B(g1 ) + v2 B(g1 + g2 )
= B(0)(g1 + g2 ) + v1 B(g1 ) + v2 B(g1 + g2 )
On a aussi B(0) = 1, B(g1 ) = B( w−2
) = 1, B(g1 + g2 ) = B(w − 1) = 0, d’où Sol2 (S, l, w) =
2
Bl(2, 2) = 3(2k−1 ) − 4.
Ainsi Sol5 (S, l, w) − Sol2 (S, l, w) ≥ 2w − 6 − 3(2k−1 ) + 4 = 2k−1 − 4, qui n’est pas borné.
Comme Solopt (S, l, w) ≥ Sol5 (S, l, w), l’écart Solopt (S, l, w) − Sol2 (S, l, w) n’est pas borné aussi.
Par ce résultat, on voit que l’algorithme en 2-blocs est arbitrairement mauvais pour quelques
familles d’instances. Ainsi, on conclut qu’autres heuristiques sont nécessaires pour essayer de
garantir la génération des solutions de meilleure qualité.
Par contre, en pratique, comme on a vu dans les expériences numériques, l’écart entre la
solution optimale et celle obtenue par 2-blocs est souvent petit, même pour les instances du
fichier CoverIIIB qui sont considérées difficiles dans la littérature.
On peut aussi trouver d’autres familles qui semblent avoir la même propriété que la famille
(S = 2(w−1), l = 2, w = 2k −1) en généralisant sa méthode de construction. Plus spécifiquement,
on peut prendre un nombre p premier quelconque, et construire la famille (S = l(w−1), l = p, w =
pk −1) pour k > 2. Un exemple plus simple trouvé par Léo Planche est (S = 2k −1, l = k, w = 1).
On n’a pas montré que ces familles d’instances ont les mêmes propriétés que la famille utilisé
pour montrer le théorème, mais les résultats expérimentales semblent confirmer cette conjecture.
Dans le futur, on pourrait analyser la structure de ces familles d’instances avec plus de
détails, et essayer de déterminer si la solution 5-bloc de ces instances est toujours équivalent à la
structure de 4 blocs mono-orientés autour d’un trou comme expliqué dans la démonstration du
théorème, ou s’il y a des instances pour lesquelles 5-blocs peut faire mieux. On pourrait aussi
observer les solutions en L-blocs et les comparer à celles obtenues par 5-blocs, pour conclure si ce
type d’instance est particulièrement mauvais pour l’algorithme en 2-blocs ou aussi pour autres
heuristiques comme le 5-bloc.
7
Figure 3: Structure d’un coupe 5-blocs. Origine: http://lagrange.ime.usp.br/~lobato/
packing
3
3.1
Heuristiques plus efficaces: 5-blocs et L-blocs
L’heuristique en 5-blocs
L’heuristique en 5-blocs généralise l’idée de 2-blocs dans le sens que l’instance originale est divisée
en 5 rectangles récursivement comme dans la figure 3.
Contrairement à l’algorithme en 2-blocs, aucune façon d’appliquer cette heuristique en temps
polynomial (et utilisation mémoire raisonnable) n’est connue. Toutefois, comme montrent par
exemple les figures de l’annexe A, 5-blocs domine 2-blocs, c’est-à-dire, les solutions 5-blocs sont
toujours au moins si bonnes que celles du 2-blocs, et il y a des instances pour lesquelles 5-blocs
trouve une solution de meilleure qualité. Cette heuristique a été introduite dans l’article [7], qui
montre expérimentalement qu’elle trouve des solutions optimales pour la plupart des instances.
On a fait un étude sur l’optimalité des solutions 5-blocs, présenté dans la section 3.3
3.2
L’heuristique en L-blocs
L’heuristique en L-blocs est la seule heuristique connue qui trouve la solution optimale pour toutes
les instances testées. Elle généralise l’heuristique en 5-blocs en faisant des coupes récursives en
L. Un L est défini comme une tuple d’entiers naturels (X, Y, x, y) où (X, Y ) est un rectangle de
cotés X, Y et (x, y) est un plus petit rectangle supprimé du grand rectangle. La figure 4 montre
un exemple de structure récursive en L-blocs.
Cette heuristique a été introduite par l’article [5] et, même après optimisations, comme en
[3] et [2], elle reste très lente pour les instances plus difficiles, ayant besoin de plusieurs minutes
pour trouver une solution. Elle est, par contre, plus performante que la résolution du modèle en
PLNE, et semble donner toujours la solution optimale.
3.3
Expériences numériques
On a utilisé le code de [2], téléchargeable sur http://lagrange.ime.usp.br/~lobato/packing/,
avec quelques modifications pour les tests de cette section. Le langage utilisé est le C++ avec le
flag d’optimisation -O3. Les tests ont été faits sur une machine Intel Core i5-3337U @ 1.8GHz.
Notre principal objectif était obtenir une liste d’instances avec des propriétés intéressantes,
par exemple, découvrir la quantité d’instances des fichiers de la littérature ont une solution
L-blocs meilleure que la solution 5-blocs. Cette expérience a trouvé 186 instances (parmi les
196557 utilisées aussi pour les expériences de la section 2.2) avec la propriété souhaitée. La liste
8
Figure 4: Exemple de structure en L-blocs. Origine: http://lagrange.ime.usp.br/~lobato/
packing
complète peut être obtenue sur https://ensiwiki.ensimag.fr/index.php/Gabriel_Mattos_
Langeloh_(avec_Vincent_Jost)_:_Un_casse-t%C3%AAte_qui_vaut_cher:_The_Pallet_Loading_
Problem.
Aucune instance I où SolL (I) − Sol5 (I) > 1 n’a été trouvé, c’est-à-dire, l’écart entre les deux
solutions est toujours 1 quand 5-bloc n’est pas optimale dans ces fichiers de test. Une question
intéressante à analyser dans le futur est si cette propriété est vraie pour toutes les instances, ou
s’il y a des cas de grande taille pour lesquels l’écart entre les deux solutions est plus grand que
1. Dans ce cas, on peut poser la même question qu’on a répondu pour le 2-blocs: "est-ce que
l’écart entre SolL et Sol5 est borné?"
4
4.1
Conclusion
Résumé du travail
Ce travail a expliqué brièvement les heuristiques utilisées dans la littérature pour résoudre le
Pallet Loading Problem et traité avec plus de détail l’heuristique en 2-blocs, qui est connue pour
être de temps polynomial. On a utilisé les expériences numériques pour faire une conjecture
sur la qualité des solutions produites par cet algorithme et on a montré que cette conjecture est
vraie. Ce résultat théorique, si comparé aux écarts trouvés dans les presque 200000 instances
des fichiers de test, montre que les propriétés imposées sur les instances de ces fichiers sont, dans
un certain sens, très fortes, parce qu’il y a des instances de structure simple avec des propriétés
importantes comme celle qu’on a montré dans le Théorème 1 qui ne sont pas dans les fichiers
de test. Ainsi, on peut faire des conjectures similaires sur la qualité des solutions des autres
heuristiques, à commencer par le 5-blocs, malgré les très bons résultats de cet algorithme dans
tous les tests connus.
4.2
Bilan du module IRL
Ce projet m’a permis d’appliquer mes connaissances mathématiques et informatiques dans un
sujet de recherche intéressant de façon très variée. Dans le point de vue informatique, j’ai
programmé en Haskell, j’ai modifié le code C++ d’autres auteurs, j’ai essayé d’exécuter certaines
parties de l’algorithme en 2-blocs en parallèle et j’ai observé qui, dans ce cas, même si en théorie
le parallélisme pourrait être utile, en pratique l’overhead est trop haut. De la coté mathématique,
j’ai lu plusieurs définitions et théorèmes utiles pour la compréhension des algorithmes, j’ai fait
9
plusieurs conjectures (la plupart a été rapidement démontré inutile) et finalement j’ai trouvé une
conjecture de résultat positif et la démontré. Cette expérience a aussi me permis d’apprendre
a lire les articles scientifiques rapidement et d’extraire les informations utiles pour mon travail.
Ainsi, je considère que l’expérience du IRL a été très positive pour moi, que j’ai appris des choses
utiles en général et aussi trouvé quelques bons résultats.
4.3
Remerciements
Merci à Vincent Jost par le sujet très intéressant et par le support pendant la durée du projet
et à Léo Planche par les discussions, suggestions et la génération des figures vertes du rapport.
References
[1] FW Barnes. Packing the maximum number of m× n tiles in a large p× q rectangle. Discrete
Mathematics, 26(2):93–100, 1979.
[2] Ernesto G Birgin, Rafael D Lobato, and Reinaldo Morabito. An effective recursive partitioning approach for the packing of identical rectangles in a rectangle. Journal of the Operational
Research Society, 61(2):306–320, 2008.
[3] Ernesto G Birgin, Reinaldo Morabito, and Fabio H Nishihara. A note on an l-approach
for solving the manufacturer’s pallet loading problem. Journal of the Operational Research
Society, 56(12):1448–1451, 2005.
[4] Kathryn A Dowsland. A combined data-base and algorithmic approach to the pallet-loading
problem. Journal of the Operational Research Society, pages 341–345, 1987.
[5] Lauro Lins, Sóstenes Lins, and Reinaldo Morabito. An l-approach for packing (ℓ, w)rectangles into rectangular and l-shaped pieces. Journal of the Operational Research Society,
54(7):777–789, 2003.
[6] Gustavo HA Martins and Robert F Dell. The minimum size instance of a pallet loading
problem equivalence class. European Journal of Operational Research, 179(1):17–26, 2007.
[7] R Morabito and S Morales. A simple and effective recursive procedure for the manufacturer’s
pallet loading problem. Journal of the Operational Research Society, pages 819–828, 1998.
[8] Josef Neliβen. How to use structural constraints to compute an upper bound for the pallet
loading problem. European Journal of Operational Research, 84(3):662–680, 1995.
[9] Alexander G Tarnowski, Johannes Terno, and Guntram Scheithauer. A polynomial time algorithm for the guillotine pallet loading problem. Infor-Information Systems and Operational
Research, 32(4):275–287, 1994.
A
Instances avec grand écart entre la solution 2-bloc et
5-bloc
Les figures suivantes montrent quelques exemples d’instances de la famille (S = 2(w − 1), l =
2, w = 2k − 1) pour k de 3 à 6, avec ses solutions 2-bloc, 5-bloc et l’écart entre les deux. Les
solutions en 2-blocs ne sont pas forcement celles décrites dans la preuve du Théorème 1, car elles
10
ont été générées avec un algorithme non-optimisé. Toutefois, comme l’algorithme est équivalent
à l’algorithme qui a été décrit dans ce rapport, même si la forme des solutions est différent, ses
nombres de rectangles sont égales.
Figure 5: Instance (12, 2, 7), une instance de la famille utilisée pour montrer le Théorème 1 avec
k = 3. A gauche, la solution 2-bloc, à droite, la solution 5-bloc. Sol5 (S, l, w) − Sol2 (S, l, w) = 0.
Figure 6: Instance (28, 2, 15), une instance de la famille utilisée pour montrer le Théorème 1 avec
k = 4. A gauche, la solution 2-bloc, à droite, la solution 5-bloc. Sol5 (S, l, w) − Sol2 (S, l, w) = 4.
11
Figure 7: Instance (60, 2, 31), une instance de la famille utilisée pour montrer le Théorème 1 avec
k = 5. A gauche, la solution 2-bloc, à droite, la solution 5-bloc. Sol5 (S, l, w) − Sol2 (S, l, w) = 12.
Figure 8: Instance (124, 2, 63), une instance de la famille utilisée pour montrer le Théorème 1 avec
k = 6. A gauche, la solution 2-bloc, à droite, la solution 5-bloc. Sol5 (S, l, w) − Sol2 (S, l, w) = 28.
B
Exemples d’instances où L-blocs domine 5-blocs
Les instances suivantes sont exemples où l’algorithme en L-blocs donne une solution meilleure
que le 5-blocs. Toujours à gauche c’est la solution 5-blocs, à droite celle du L-blocs.
12
Figure 9: Instance (43, 26, 7, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs à
droite.
Figure 10: Instance (49, 28, 8, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 11: Instance (57, 34, 7, 4) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 12: Instance (61, 35, 10, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
13
Figure 13: Instance (61, 38, 6, 5) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 14: Instance (61, 38, 10, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 15: Instance (63, 44, 8, 5) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 16: Instance (67, 37, 11, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
14
Figure 17: Instance (67, 40, 11, 3) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 18: Instance (74, 49, 11, 4) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 19: Instance (86, 52, 9, 5) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
Figure 20: Instance (93, 46, 13, 4) avec une solution en 5-blocs à gauche e une solution à L-blocs
à droite.
15