Académique Documents
Professionnel Documents
Culture Documents
Epigraphe
"Albert Einstein"
P a g e | ii
Dédicace
Prince-Jobinick MUKUANGALA
P a g e | iii
Remerciements
Le présent travail n’aurait pas été possible sans l’aide, le soutien matériel
et
Spirituel ainsi que l’apport d’innombrables personnes envers qui, nous
manifestons notre gratitude et nos sincères remerciements.
A ce sujet, nous adressons à priori, notre action de grâce et louange à
Dieu Tout Puissant qui, par sa grâce, sa protection et son amour, nous a conduits
au terme de cette étape.
Ainsi, à la fin de la rédaction de notre Travail de mémoire, nous tenons à
remercier profondément le Professeur Ruffin-Benoit NGOIE MPOY et
l’Assistant Fabrice BONKILE qui l’ont dirigé, qui se sont dépensé corps et âme
pour la réalisation de ce dernier.
Nos remerciements vont aussi à tous les Professeurs, Chefs de Travaux
et Assistants de l’Institut Supérieur Pédagogique de Mbanza-Ngungu, en
général, et particulièrement ceux du Département de mathématique pour leur
encadrement : les Professeurs : OKITONYUMBE, OKITOWAMBA et Jean-
Charles MBUYI ; Les Chefs de Travaux : Jean-Pierre BAKODILA, Lesa NICE
et Les Assistants : Jean-Aimé SAKULU, Fabrice BONKILE, Jean NGUNDA,
Pamela MUKOKO et la sœur Pascaline.
Nous remercions également aux membres de notre famille, nos sœurs et
frères, cousines et cousins : Charmant MUKUANGALA, Trinite
MUKUANGALA, Divin MUKUANGALA, Magnificat MUKUANGALA,
Hyppo LUMOKISA, Nene, Nercy, Vij BAKUVUIDI, Lita LUMOKISA, Daniel
NTEKITA, Pysmol LUMOKISA, Damase BAKUVUIDI, Roland KAYI,
Laurentine KIANGEBENI, Ines NKITA, Glorieuse MAKANDA, Remy
LUMOKISA, Herline LUBOKILA, Verdon MUKUANGALA, Braham
MUKUANGALA, Remerdie, Ernest, Crijedie BAKUVUIDI, Tichick KAYI.
Nous tenons à remercier aussi toutes les personnes de l’Aumônerie
Catholique des Milieux Universitaires et Intellectuels de Mbanza-Ngungu,
notamment de l’Abbé aumônier Jean-Bruno NDIADIA, Père Victor
MAMPUYA, Père Blaise, Maitre Jacquarie PHAMBU, Assistante Blandine
NDOMBE, Junior PHAMBU, Gloire TUSAVUVU, Vylia BUABU, Benny
KILESA, Christine NSIMBA, Caroline LUKALU etc.
P a g e | vi
Page |1
INTRODUCTION
1. Problématique
Pour apporter une solution au problème que pose ce centre de santé, nous
supposons que les problèmes de mariage stable et l’algorithme de Gale-Shapley
régleront les problèmes évoqués ci-dessus.
Page |2
3. Objectif du travail
4. Méthodes et techniques
Chapitre premier
PROBLEME DE MARIAGE
I.0 Introduction
L'introduction du mariage stable se réfère à l'article de David Gale et
Lloyd Shapley publié en 1962, intitulé "College Admissions and the Stability of
Marriage" (Admissions universitaires et stabilité du mariage). Cet article a
introduit l'algorithme de Gale et Shapley, qui est utilisé pour résoudre des
problèmes d'appariement dans divers domaines, tels que les admissions
universitaires, le marché du travail, etc.
L’objectif principal de ce chapitre est de présenter le problème de mariage
stable, tel que décrit par Gale et Shapley, son histoire, sa problématique, ses
propriétés, ses premières solutions, … .
I.1. Historique
David Gale est un mathématicien et économiste américain né le 13
décembre 1921 à New York et décédé le 07 mars 2008 à Berkeley.
Lloyd Shapley né le 02 juin 1923 à Cambridge, au Massachussetts et
décédé le 12 mars 2016, il est considéré par de nombreux experts comme le plus
grand théoricien des jeux depuis les travaux de Van Neumann et Morgenstern.
En 2012, il a reçu le « Prix Nobel d’économie », conjointement avec son
compatriote Alvin Roth. Ce qui récompense ses recherches sur la théorie des
jeux collaboratifs, qu’il avait notamment appliqué au problème de mariages
stables.
David Gale avait formulé la conjecture selon laquelle il existe toujours un
appariement stable dans le problème du mariage et l’avait soumise à plusieurs
collègues. Lloyd Shapley fournit immédiatement une réponse constructive, sous
Page |4
Hommes Femmes
H1 préférait f1 F1 préférait h1
H2 préférait f2 F2 préférait h2
H3 préférait f4 F3 préférait h4
H4 préférait f3 F4 préférait h3
Nous venons de stabiliser le couple, donc la stabilité est vérifiée.
Exemple 1.2. Nous avons une matrice de classement de trois hommes
(α, β et θ) et trois femmes (A, B et C)
A B C
α 1 2 3
β 3 1 2
θ 2 3 1
L'algorithme de Gale et Shapley fonctionne de la manière suivante :
1. Chaque homme propose initialement à la femme qu'il préfère le plus.
2. Chaque femme examine toutes les propositions qu'elle a reçues et rejette
toutes sauf celle de l'homme qu'elle préfère le plus.
3. Les hommes non retenus proposent à leur deuxième femme préférée.
4. Les femmes examinent à nouveau toutes les propositions et gardent la
meilleure.
5. Le processus se répète jusqu'à ce que chaque femme ait reçu une seule
proposition.
6. L'appariement final est obtenu lorsque chaque homme et chaque femme
ont une seule proposition acceptée.
Cet algorithme garantit qu'un appariement stable sera trouvé, c'est-
à-dire qu'il n'existe pas d'autres appariements possibles dans lesquels certains
individus préfèrent mutuellement s'apparier plutôt que de rester avec leur
partenaire actuel.
L'algorithme de Gale et Shapley a de nombreuses applications
pratiques, notamment dans les domaines de l'appariement des résidents et des
hôpitaux, des étudiants et des universités, des employés et des employeurs, etc.
[Gale & Shapley, 1962].
1.4.1. Stabilité
L’un des objectifs annoncés par Gale et Shapley est d’étudier la
« stabilité » des mariages qui résultent de leur algorithme. Leur
concept de stabilité repose sur deux conditions minimales.
1. Aucun individu ne préfère un autre membre à son partenaire actuel : cela
signifie qu'aucun homme ne préfère une autre femme à sa partenaire
actuelle, et qu'aucune femme ne préfère un autre homme à son partenaire
actuel.
2. Il n'existe pas de pair d'individus qui préfèrent mutuellement s'apparier
plutôt que de rester avec leur partenaire actuel.
Lorsque ces deux conditions sont satisfaites, on dit que l'appariement
est stable car il n'y a pas de possibilité d'amélioration pour les
individus impliqués.
P a g e | 11
qu’aucune femme n’a été proposée il y aura des rejets tant qu’il y aura de
nouvelles propositions, mais comme aucun homme ne peut proposer à la même
femme plus d’une fois, chaque femme est sure de recevoir une proposition le
moment venu. Dès que la dernière femme reçoit sa proposition, la cour est
terminée, et chaque femme est maintenant obligée d’accepter l’homme sur sa
ficelle.
En prétendant que cet ensemble de mariage est stable. Supposons que
John et Mary ne sont pas mariés mais John préfère Mary à son épouse Jane ;
John doit alors avoir proposé à Mary à un certain stade et a ensuite été rejeté en
faveur de quelqu’un que Marie a aimé. Il n’y a pas d’instabilité. Visiblement
l’algorithme renvoie bien un couplage stable dans tous les cas. Puisqu’on
remarque qu’après la réception de sa première proposition, une femme ne
redevient jamais libre. En effet, elle peut changer de fiancé si une meilleure
offre apparait mais ne peut pas perdre son fiancé actuel. En revanche, un homme
peut être fiancé à un certain point et redevenir libre au cours de l’algorithme.
1.4.3. Conditions
Pour que l’algorithme de Gale et Shapley produise une meilleure
solution, les hommes tout comme les femmes sont obligés d’être
sincères dans l’élaboration de leur liste de préférence et ne pas la
manipuler ni la communiquer à l’autre groupe (de femmes ou
d’hommes) au cours de l’exécution.
P a g e | 13
Surface
NLANDU VAKANDA SENTI
DE POSTE M NELL
E
WETUSA MARIE Fille de
F Surface
NLANDU URCILE SAGE
F A1 FEMM
E
BILEPO DORCAS INFIR
F A1 MIERE
LUKENI VALVINE SAGE
F A1 FEMM
E
II.6. Organigramme du Centre de Santé Cerphytoco
SŒUR
GESTIONNAIRE
INFIRMIER TITULAIRE MEDECIN
PHARMACIE
P a g e | 19
P a g e | 20
Le groupe2 et groupe3 sont les deux groupes qui font les rotations
moyennant une durée de trois jours. Si les agents du groupe2 travaillent de 10h-
17h30 durant trois jours successifs et que ceux du groupe3 de 17h30-7h30, alors
le groupe3 prendra le repos de deux jours pour revenir dans la vacation de 10h-
17h30. Pour le groupe1, eux n’ont pas de rotation à faire c’est-à-dire ils ne
travaillent que de 7h30 à 15h et ils ont le jour de repos le dimanche.
P a g e | 23
Chapitre Troisième
GENERALITE SUR LE LANGAGE JAVA
III.1. Le concept de base
Une classe est le support de l’encapsulation : c'est un ensemble de
données et de fonctions regroupées dans une même entité.
Une classe est une description abstraite d'un objet. Les fonctions qui
opèrent sur les données sont appelées des méthodes. Instancier une classe
consiste à créer un objet sur son modèle. Entre classe et objet, il y a en
quelque sorte, le même rapport qu'entre type et variable.
Java est un langage orienté objet : tout appartient à une classe sauf les
variables de type primitives. Pour accéder à une classe il faut en déclarer une
instance ou objet. Une classe comporte sa déclaration, des variables et la
définition de ses méthodes.
Une classe se compose en deux parties : un en−tête et un corps. Le corps
peut être divisé en 2 sections : la déclaration des données ou des constantes et la
définition des méthodes. Les méthodes et les données sont pourvues d'attributs
de visibilité qui gère leur accessibilité par les composants hors de la classe.
III.2. Syntaxe de base du Langage
Le langage Java inclut 99% de la syntaxe du langage C (les pointeurs
n'apparaissent pas clairement mais à l'exception des types primitifs tout n'est que
pointeur.)
La première application Java, l'application « Hello.java »
III.2.1. Quelques remarques.
Les conventions de codage du langage Java peuvent être consultées à
l'adresse suivante :
ftp://ftp-developpez.com/cyberzoide/java/JavaStyle.pdf
A retenir les classes doivent avoir leur première lettre en majuscule, à
l'exception des constantes qui elles seront toutes écrites en majuscules, toutes les
autres entités (variables, variables de classes, variables d'instances, services de
classes, services d'instances) commenceront par une minuscule.
Il ne peut y avoir en Java, qu'une seule classe public par « fichier.java », si
il y a une classe public dans un « fichier.java » le nom de la classe doit être le
nom du fichier.
Par exemple,
public class Test
{
static int somme(int i, int j)
P a g e | 25
{
return i+j;
}
}
Il y a dans ce fichier une classe public qui s'appelle Test, elle doit
donc être dans le fichier « Test.java ».
III.2.1. Les mot clef « private » et « public »
Tant que les différents concepts objets ne sont pas présentés, il est difficile
de présenter la notion de contexte de classe. Dans un premier nous allons
considérer que le contexte de classe correspond au contexte d’un module écrit en
C. Nous détaillerons la signification de cette notion après avoir brièvement
présentés les deux autres mots clefs qui sont « public » et « private ». Les mots
clefs « private » et « public » sont des mots clefs qui permettent le contrôle de
l'accès à l'information.
L'accès à l'information en Java est contrôlé par l'utilisation de 4 mots
clefs:
Public toute entité qui contient la classe peut accéder (lecture/écriture)
à l'information publique.
Protected seules les classes définies dans le même package ou qui
héritent de la classe peuvent avoir accès à cette information.
Rien : dans ce cas seules les classes définies dans le même package
peuvent accéder à cette information.
Private seules les entités définis à l'intérieur de la paire d'accolades
qui définit la classe peut avoir accès à une information privée.
Pour l'instant nous ne pouvons aborder que les deux mots clefs private et
public. Pour cela on peut les rapprocher des notions abordées en C.
III.2.2. Entité de classe et Entité d'instance en Java.
Les mots clefs « public » et « private » servent donc à contrôler l'accès
aux entités des programmes que ce soit des variables ou bien des éléments
équivalent à des fonctions.
Il existe deux types différents d'entités:
• Entité de classes: Elles correspondent aux entités d'un module C. En
Java, ces entités sont précédées du mot clef « static » mais il faut
distinguer celles qui sont précédés de :
paramètre nul ne peut pas être utilisé comme un objet normal : il n'y a pas
d'appel de méthodes et aucunes classes ne peut en hériter. Le fait d'initialiser
une variable référent un objet à nul permet au ramasse miette de libérer la
mémoire allouée à l'objet.
III.3.6. Les variables de classes
Elles ne sont définies qu'une seule fois quel que soit le nombre d'objets
instanciés de la classe. Leur déclaration est accompagnée du mot clé static
Exemple 1 :
public class MaClasse()
{
static int compteur = 0;
}
L'appartenance des variables de classe à une classe entière et non à un
objet spécifique permet de remplacer le nom de la variable par le nom de la
classe.
Exemple 2 :
• Maclasse m = new MaClasse ();
• Int c1 = m. compteur;
• Int c2 = MaClasse. Compteur;
NB :
• c1 et c2 possèdent la même valeur.
• Ce type de variable est utile pour par exemple compter le nombre
d'instanciation de la classe qui est faite.
Exemple 2 :
class MaClasse() {
String chaine = " test " ;
Public String getChaine() { return chaine} ;
// est équivalent à public String getChaine (this.chaine);
}
This est aussi utilisé quand l'objet doit appeler une méthode en se passant
lui-même en paramètre de l'appel.
III.3.7. L'opérateur INSTANCEOF.
L'opérateur instanceof permet de déterminer la classe de l'objet qui lui est
passé en paramètre. La syntaxe est objet instanceof classe
Exemple 1 :
void testClasse(Object ob) { if (ob instanceof MaClasse )
System.out.println(" ob est une instance de la classe MaClasse "); else
System.out.println(" ob n'est pas un objet de la classe MaClasse "); }
Il n'est toutefois pas possible d'appeler une méthode de l'objet car il est
passé en paramètre avec un type Object
Exemple 2 :
void
afficheChaine(Object ob) { if
(ob instanceof MaClasse)
System.out.println(ob.getChaine());
// erreur à la compilation car la méthode
getChaine() //n'est pas définie dans la classe Object
}
Pour résoudre le problème, il faut utiliser la technique du casting
(conversion).
Exemple 3 :
void
afficheChaine(Object ob) { if
(ob instanceof MaClasse)
{
P a g e | 31
Mécanisme de réflexion (les objets, les types, les services sont considérés
comme des objets de première classe).
III.6. Interface et implémentation
Nous retrouvons en Java les mêmes notions que pour un module C:
Interface : L'ensemble des informations qui peuvent être à l'extérieur
d'un module. En principe, les informations contenues dans l'interface
ce résume à un ensemble de services, on parle dans ce cas, d'interface
fonctionnelle public. La propriété importante liée à cette notion est
celle de compatibilité ascendante de l'interface. Cette propriété
demande à ce que les ensembles qui étaient valables à un instant T0
continue à un instant T1 postérieur à T0.
Cette propriété concerne aussi bien les services que les variables.
}
}
Les différents éléments syntaxiques du programme sont:
1. La classe Hello est une classe publique elle doit donc être définie dans le
fichier « Hello.java ».
2. Si on veut exécuter cette application Java il faut exécuter la suite de
commande
Java Hello.java
Java Hello
En java, la notion de programme principal est différente de celle du
langage C. Il peut y avoir plusieurs occurrences
III.7. Types primitifs en Java
On appellera type primitif tous les types qui ne sont pas liés à une classe
et qui représentent en quelque sorte les briques de bases nécessaires à la
construction des classes. Afin de pouvoir participer à la portabilité du langage
java il est nécessaire que la taille des types soit fixés dans la norme de Java.
Les types primitifs sont les suivant: byte (8 bits), short (16 bits), Int (32
bits), long (64 bits), float (32 bits), double (64 bits), char (16 bits), booléen (1
bit).
2. La variable s est une variable qui référence un objet de type String (plus
exactement de type compatible). La valeur de la variable s est celle de
l'adresse de l'objet référencé c'est à dire
0XAAFF.
A l’exception des types primitifs, les variables ne représentent que des
références à des entités (objets), nous allons voir que dans la section suivante,
l’affectation s’exprime comme un changement de référence et non un
changement de contenu de l’objet. Il s’agit s’une simple réaffectation de
pointeur.
III.9. Interprétation des opérateurs =, ==
L'opérateur d'affectation x =y consiste à mettre dans la variable x les bits
de la variable y. Il s'agit d'une affectation bit à bit. Suivant le type des variable x
et y, il existe deux interprétations :
1. Si x et y sont des types primitifs, la variable x prend alors la même valeur
que la valeur y.
2. Si x et y ne sont pas des types primitifs, alors la variable x référence la
même entité (objet) que la variable y. Les variables x et y sont des
variables qui adressent le même objet. Ceux sont deux noms qui
permettent de manipuler une même chose.
Type [] nom; déclare une variable nom qui est une référence sur un
tableau de type T. En Java, T [] représente véritablement un type. Un
exemple de déclaration peut-être.
Int [] tableau: La variable tableau est une référence à un objet de type
tableau de int (int []). Dans ce cas, la déclaration en langage C la plus
voisine est int *tableau;
P a g e | 35
Il n'y pas la possibilité en Java de déclarer la taille d'un tableau en même
temps que la déclaration. L'instruction int t[10] n'est pas correcte en Java.
Pour les tableaux, la syntaxe pour créer un un objet de type tableau est:
New int[10] crée un tableau qui contient 10 entiers
New String [10] crée un tableau de 10 référence à des objets de type
String, par contre aucun objet de type string n'est créé avec cette
instruction.
L'instruction new T[N], équivalente à malloc(sizeof(T)*N), à deux
interprétations en fonction de la nature de T :
Si T est un type primitif alors la place mémoire allouée par cet appel
est N fois la taille d'un T. Les N cellules crées sont consécutives.
Si T n'est pas un type primitif alors la place mémoire alloué par cet
appel est N fois la taille d'une variable référence à un objet de type T.
Il n'y a pas de création d'objet.
Pour une variable qui référence n'importe quel tableau t de n'importe quel
type, on peut connaître la taille d'un tableau en utilisant l'instruction :
t.length
Un premier exemple qui permet de remplir un tableau d'entier avec les 10
premiers nombre pair public class ExempleVecteurPair
{
public static void main (String []argv)
{
int [] tab; tab
= new int[10];
for(int i=0; i<
tab.length; i++)
tab[i] = 2*i;
}
}
P a g e | 36
{
int []
[] tab; tab =
new int[3]
[];
{
}
{ tab[i]
[j]=
i+j+1 ;
}
{
{
}
}
}
}
Chapitre Quatrième
ETABLISSEMENT DES HORAIRES DE
PERMANENCE DES AGENTS PAR L’ALGORITHME
DE MARIAGE STAGE, IMPLEMENTATION EN
JAVA : CAS DU CENTRE DE SANTE CERPHYTOCO
DE KISANTU
IV.1. Les données
Avant d’appliquer l’algorithme de Gale et Shapley pour produire un
horaire de permanence des agents stable et juste, il faut d’abord
considérer les données disponibles, les traiter afin de les rendre
utilisables dans l’algorithme de Gale et Shapley.
Selon la définition du problème d’appariement stable reprise ci-
haut, ce problème consiste à trouver un appariement optimal entre deux
ensembles d'individus, où chaque individu a une préférence sur les membres de
l'autre ensemble. L'objectif est de trouver un appariement dans lequel aucun
individu ne préfère un autre membre à son partenaire actuel et où il n'existe pas
de pair d'individus qui préfèrent mutuellement s'apparier plutôt que de rester
avec leur partenaire actuel.
Les deux ensembles d’individus que nous disposons sont : les Agents
et les Groupes de vacation, détaillés de manière suivante :
P a g e | 39
Agents
NOM, POSTNOM & PRENOMS
WETUSA MARIE
NLANDU URCILE
BILEPO DORCAS
LUKENI VALVINE
Groupe de vacation
P a g e | 40
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
Gr Gr
On a donc ajouter des suffixes A, B,C,D,E,F,G
De tel en sorte que celui qui est affecté au Groupe1 et celui qui est
affecté au Groupe1_A ou Groupe1_G sont affectés au même groupe. Il
P a g e | 42
Sr MBELA PALMYRE
Gro Gro Gro Gro Gro
KIALULENDO
MPOVA CLARISSE Gro Gro Gro Gro Gro
…
LUKENI VALVINE
Gro Gro Gro Gro Gro
Préférence des Groupes
G Sr BASILUA MARIE LUVUNGA NDOMBASI FEROS
r BOSCO
o
u
p
e
1
G Sr MBELA PALMYRE NDUNDU NZINGA VICTORINE
r
o
u
p
e
2
_
G
G KIALULENDO MPOVA BASEYA KIYA JOSE
r CLARISSE
o
u
p
e
1
_
A
P a g e | 43
… … …
G LUKENI VALVINE TONSI MAKIADI CHRETIENNE
r
o
u
p
e
1
_
B
Vu la grande taille de ces deux tableaux on ne pourra les représenter
dans ce document-ci.
Ayant maintenant nos deux ensembles d’individus de même taille on
peut maintenant et facilement appliquer l’algorithme de Gale et
Shapley sur nos données.
IV.3. Implémentation en Java
Vu la grande masse de données qu’il y a, exécuter l’algorithme de
Gale et Shapley sur ces données à la main, serait fastidieux. C’est
pourquoi nous avons implémenté cette solution en Java, en mettant en
place une application qui va permettre de faire cela automatiquement
et à moindre temps.
IV.4. Présentation de l’application
Cette application s’appelle CERPHYTOCO_PLANNING, elle est
connectée à une base de données qui contient 3 tables, Mariage, Agent
et Planning.
La table Agent permet d’enregistrer les agents qu’on va ensuite
appeler dans l’application.
La table Mariage c’est la table qui enregistre les appariements stables
que l’application va produire.
Enfin la table planning c’est une table qui permet de remettre la
dénomination des groupes comme avant afin de ne pas troubler les
décideurs.
Accueil de l’application
Dès vous ouvrez l’application vous tombez sur cette interface
d’accueil, composée de deux espaces une colonne de menu avec ses
P a g e | 44
Le menu Planification
Mis à part la colonne menu qu’on a déjà présenté, cette interface a un
espace composé d’un tableau qui reprend les affectations stables afin
de permettre aux décideurs de s’y référer, il y a aussi deux comboBox
dont le premier contient les agents enregistrés dans la base de données,
le deuxième contient le trois groupes de vacation. Le bouton Affecter a
pour rôle d’affecter un agent à un groupe. Exemple dans le tableau ci-
dessous on voit que l’agent Sr MBELA est affectée au groupe
Groupe3E, donc on lui affecte au Groupe3 tout court.
P a g e | 45
Le menu Agent
Cette interface a un espace composé d’un tableau qui reprend les
agents enregistrés dans la base de données, il y a aussi les boutons
chacun faisant le rôle marqué sur son étiquette.
Le menu Planning
Cette interface a un espace composé d’un tableau qui reprend le
nouveau planning en bonne et due forme enregistré dans la base de
données, il y a aussi un TextField qui affiche la date du jour mais dans
lequel on doit placer la semaine en vigueur pour ce nouveau planning.
Ensuite il y a un bouton imprimer qui permet d’imprimer le planning
en question.
P a g e | 46
Le planning imprimé
P a g e | 47
P a g e | 48
CONCLUSION GENERALE
Nous voici au terme de notre étude qui a porté sur l’Etablissement
des horaires de permanence des agents par l’algorithme de mariage stage,
implémentation en Java : cas du centre de santé Cerphytoco de Kisantu.
Après avoir traités ces problèmes du centre de santé Cerphytoco de
Kisantu, nous avons constatés qu’ils peuvent ajouter d’autres agents dans leur
centre en utilisant cet algorithme qui leur permettra de faire un appariement des
agents avec leur vacation de façon optimale en utilisant l’algorithme de Gale et
Shapley.
Enfin, hormis les notions évoquées dans ce travail, beaucoup
d’autres notions peuvent être appliquées dans certains domaines ou travails.
Nous suggérons aux chercheurs qui s’intéresseront à ce sujet de
tenir compte des fonctions de chaque agent parce qu’il y a des fonctions qui ne
peuvent appartenir dans certains groupes d’autres aussi sont obligées d’être que
dans un groupe donné, par exemple les gestionnaires doivent seulement
appartenir au groupe1.
P a g e | 49
BIBLIOGRAPHIE
Gale, D., Shapley, L. S. (1962). College Admissions and the Stability
of Marriage. American Mathematical Monthly, 69(1), 9-15.
Roth, A. E., Sotomayor, M. (1990). Two-Sided Matching: A Study in
Game-Theoretic Modeling and Analysis. Cambridge University Press.
Manlove, D. F. (2013). Algorithmics of Matching Under Preferences.
World Scientific Publishing Company.
Gusfield, D., Irving, R. W. (1989). The Stable Marriage Problem:
Structure and Algorithms. MIT Press.
Roth, A. E. (1984). The Evolution of the Labor Market for Medical
Interns and Residents: A Case Study in Game Theory. Journal of
Political Economy, 92(6), 991-1016.
Cechlárová, K., Gurvich, V., Mönch, L., & Sotskov, Y.N. (2011).
Combinatorial Optimization and Applications. Springer.
Irving, R. W. (1985). An Efficient Algorithm for the "Stable
Roommates" Problem. Journal of Algorithms, 6(4), 577-595.
Shapley, L. S. (1984). A Note on the Stable Marriage Problem.
Discrete Applied Mathematics, 8(3), 343-344.
Knuth, D. E., Yao, A. C., & Mccloskey, D. N. (1976). An Analysis of
Optimal Matching under Preferences. Algorithms & Complexity: New
Directions and Recent Results, 141-184.
Honoré, B. E., & Lippman, S. A. (1985). An Inverse Duality Approach
to the Linear Hospital Resident Assignment Problem. Management
Science, 31(5), 590-601.
Gusfield, D. (1987). Stability in the Marriage Problem: A Unified
Approach. SIAM Journal on Computing, 16(1), 111-128.
Gallo, G., & Stardom, M. (1997). Stable Matchings: Structure and
Algorithms. MIT Press.
P a g e | 50
Remerciements.................................................................................................................iii
Sigles et abréviations........................................................................................................iv
INTRODUCTION.............................................................................................................1
1...................................................................................................................Problématique
............................................................................................................................................1
2..........................................................................................................................Hypothèse
............................................................................................................................................1
3.............................................................................................................Objectif du travail
............................................................................................................................................1
4.................................................................................................................Choix du travail
............................................................................................................................................2
5.....................................................................................................Méthodes et techniques
............................................................................................................................................2
6.......................................................................................................Subdivision du travail
............................................................................................................................................2
Chapitre premier..............................................................................................................3
PROBLEME DE MARIAGE...........................................................................................3
I.0 Introduction.................................................................................................................3
I.1. Historique....................................................................................................................3
P a g e | 51
Théorème 1.1.....................................................................................................................7
1.4.1. Stabilité....................................................................................................................8
1.4.3. Conditions..............................................................................................................10
Chapitre deuxième..........................................................................................................14
b.............................................................................................................Comité de gestion:
..........................................................................................................................................14
P a g e | 52
Chapitre Troisième.........................................................................................................20
Exemple :.........................................................................................................................23
Exemple 1 :......................................................................................................................23
Exemple 2 :......................................................................................................................23
Exemple 1 :......................................................................................................................24
Exemple 2 :......................................................................................................................24
Exemple 1 :......................................................................................................................24
Exemple 2 :......................................................................................................................25
Exemple 2 :......................................................................................................................25
Exemple 1 :......................................................................................................................25
Exemple 2 :......................................................................................................................26
Exemple 3 :......................................................................................................................26
CONCLUSION GENERALE........................................................................................33