Sdic PL0277

UNIVERSITÉ MOHAMMED V de Rabat
Faculté des Sciences
Département d’Informatique
Filière Licence fondamentale
en Sciences Mathématiques et Informatique
PROJET DE FIN D’ÉTUDES
intitulé :
Implémentation, test et simulation de

l’algorithme HONGROIS en JAVA .
Présenté par :
AIT MANSOUR GHIZLANE
ABBAD ASMAE
soutenu le 25 Juin 2016 devant le Jury
M.El AMRANI Younés Professeur à la Faculté des Sciences - Rabat Encadrant

M.OUSSAMA Reda Professeur à la Faculté des Sciences - Rabat Examinateur
Année universitaire 2015-2016
Remerciements
— Au terme de ce travail, nous tenons à exprimer notre
profonde gratitude et nos sincères remerciements à
notre encadrant Professeur EL AMRANI YOUNES,
pour tout le temps qu’il nous a consacré, ses conseils
précieux, et pour la qualité de son suivi durant toute
la période de notre projet.
— Nous tenons aussi à remercier vivement les membres

de jury M.OUSSAMA Reda pour avoir accepter
d’examiner notre travail .
— Nous souhaitons aussi envoyer nos sincères remercie-

ments à tous ceux qui n’ont pas hésité pour donner
de l’aide et le soutien pour réaliser ce projet dans les
meilleures conditions.
2016 page 1
Résumé
Ce projet consiste l’implémentation en java de l’al-

gorithme Hongrois qui prend en entrée la taille de
la matrice(appelée table de coûts) et ces éléments et
comme sortie le calcul du cout.
Ce travail a pour but de résoudre le problème d’af-

fectation en affectant les éléments d’un ensemble à
ceux d’un autre ensemble de sorte que la somme des
coûts des affectations soit minimale.
Mots clés : JAVA,COUT,RECHERCHE OPÉRA-

TIONNELLE,PROBLÈME D’AFFECTATION ,AL-
GORITHME HONGROIS.
Abstract
The main objective of this project involves the im-

plementation of Hungarian algorithm in JAVA that
takes as input the size of the matrix (called table of
costs) and its elements and the output as the calcu-
lation of the cost.
This work aims to solve the problem of allocation by
assigning the elements of a set to those of another
elements so that the sum of the assignment cost will
be minimal.
Keywords JAVA,COST,OPERATIONAL RE-

:
SEARCH,ASSIGNMENT PROBLEM ,HANGA-
RIAN ALGORITHM
Table des matières
1 Problème d’affectation 3
1.1 Introduction . . . . . . . . . . . . . . 3
1.2 Historique . . . . . . . . . . . . . . . 3
2 L’algorithme Hongrois 4
2.1 les étapes de l’algorithme : . . . . . . 4
2.2 Exemple . . . . . . . . . . . . . . . . 5
3 Diagramme de classe :vue générale 9
4 Présentation des implémentation des

classes du modèle 10
4.1 Définition des classes . . . . . . . . . 10
4.1.1 Rôle de la classe Cellule dans
l’implémentation de l’AH : . . 10
4.1.2 Rôle de la classe Matrhong
dans l’implémentation de
l’AH : . . . . . . . . . . . . . 10
4.2 L’interface graphique . . . . . . . . . 12
5 Conclusion 15
6 Annexe 17
6.1 Classe Cellule . . . . . . . . . . . . 17
6.2 Classe Matrhong : . . . . . . . . . 17
6.3 Classe main : . . . . . . . . . . . . 26
6.4 Classe interface : . . . . . . . . . . 26
TABLE DES MATIÈRES
Introduction générale
La plupart des algorithmes proposés pour le pro-

blème d’affectation sont adapatés des algorithmes
pour le problème de flot à coût minimum. L’algo-
rithme hongrois est une adaptation de l’algorithme
primal-dual,il résout ce problème en temps polyno-
mial.
2016 page 2
1 PROBLÈME D’AFFECTATION
Algorithme HONGROIS :Présentation
1 Problème d’affectation
1.1 Introduction
L’algorithme hongrois permet de résoudre le problème d’assi-
gnement. Si on considère deux ensembles A et B disjoints (de
même cardinal), et une fonction :
où c représente le coût de la paire (a, b). Cet algorithme

permet d’assigner les éléments de A aux éléments de B,
ie. établir une bijection entre les ensembles A et B, pour
minimiser le coût total. L’algorithme hongrois permet donc
de trouver un assignement, c’est-à-dire une bijection
telle qu’on minimise :
cet algorithme consisterait à calculer, pour chaque assigne-

ment réalisable, la somme ci-dessus, afin de déterminer l’assi-
gnement optimal.
1.2 Historique
L’Algorithme Hongrois a été proposé en 1955 par le mathé-
maticien américain Harold Kuhn, qui l’a baptisé « méthode
hongroise » par ce qu’il s’appuyait sur des travaux antérieurs
de deux mathématiciens hongrois : Dénes Konig et Jen
Egerváry . James Munkres a revu l’algorithme en 1957 et a
prouvé qu’il s’exécutait en temps polynomial. L’algorithme
est vu comme une des premières apparitions de l’idée de
schéma primal-dual.
2016 page 3
2 L’ALGORITHME HONGROIS
2 L’algorithme Hongrois
2.1 les étapes de l’algorithme :
L’algorithme Hongrois peut être décrit de la façon suivante :
1. chacune des rangées, identifier le coût minimal et soustraire
celui-ci de chacun des coûts dans la rangée correspondante.
2. Dans chacune des colonnes, identifier le coût minimal et
soustraire celui-ci de chacun des coûts dans la colonne cor-
respondante.
3. Vérifier si une affectation de coût 0 est possible .Une façon
de procéder à cette vérification est d’identifier le nombre
minimum de lignes horizontales et verticales permettant
de « barrer » ou couvrir toutes les entrées nulles. Si ce
nombre minimum correspond au nombre de rangées dans
la matrice, alors une affectation de coût 0 est possible et
il faut aller en suite à l’étape 6 ; sinon il faut continuer à
l’étape 4.
4. Ajouter des entrées nulles dans la matrice de la façon sui-
vante :
• Identifier le plus petit coût non couvert dans la matrice.
• Soustraire le plus petit coût non couvert de chacune des
entrées non couvertes dans la matrice.
• Ajouter le plus petit coût non couvert aux entrées se
trouvant à l’intersection d’une ligne horizontale et verti-
cale (i.e., les entrées qui sont couvertes par deux lignes).
Il faut noter que les coûts dans les entrées couvertes par
une seule ligne ne changent pas.
5. 5. Répéter les étapes 3 et 4 jusqu’à ce qu’une affectation de
coût 0 soit possible.
6. Procéder à l’affectation optimale en considérant, une à une,
les entrées de coût nul. Pour ce faire, toujours donner la pré-
férence aux rangées et aux colonnes ayant une seule entrée
de coût nul. À chaque fois qu’une entrée est choisie, éliminer
la rangée et la colonne correspondante. Répéter jusqu’à ce
que toutes les rangées et colonnes aient été éliminées. Une
schématisation simpliste de l’algorithme hongrois pourrait
être la suivante :
2016 page 4
2.2 Exemple
Soit La société Beta possédant quatre ateliers : fonte,
moulage, laminage et traitement thermique, qu’on va
nommer respectivement F, M, L et T, pour lesquels elle
veut affecter quatre chef de service polyvalents, monsieur
A, B, C et D.
2016 page 5
Réduction des lignes : on crée une nouvelle matrice

des coûts en choisissant le coût minimal sur chaque ligne
et en le soustrayant de chaque coût sur la ligne.
Réduction des colonnes : on crée une nouvelle matrice des

coûts en choisissant le coût minimal dans chaque colonne
et en le soustrayant de chaque coût dans la colonne.
Maintenant, il faut déterminer le nombre minimal de

lignes nécessaires sur les lignes et les colonnes pour couvrir
tous les zéros. Si ce nombre est égal au nombre de lignes
(ou colonnes), la matrice est réduite ; aller à l’étape 5. Si
ce nombre est inférieur au nombre de lignes (ou colonnes),
aller à l’étape 4.
2016 page 6
Dans ce cas, le nombre minimal de zéro est de 3 qui est

inférieur au nombre de ligne ou colonne (4), alors on passe
à l’étape 4.
Premièrement, il faut trouver la cellule de valeur minimum
non couverte par une ligne, puis, soustraire cette valeur
de toutes les cellules non couvertes. Ensuite, ajouter cette
valeur aux cellules situées à l’intersection de deux lignes.
Et enfin, retourner à l’étape 3.
ÿ
þ
La valeur minimum des cellules non couvertes est 20. On

soustrait 20 des cellules non couvertes et on l’ajoute aux
cellules qui se trouvent à l’intersection des lignes, ceci nous
donne le tableau suivant :
Maintenant, le nombre minimal de ligne est égale à 4.
2016 page 7
La solution optimale est donc la suivante :
La solution à pour coût :
60 + 200 + 180 + 90 = 530
2016 page 8
3 DIAGRAMME DE CLASSE :VUE GÉNÉRALE
Conception
3 Diagramme de classe :vue générale
Figure 1 – Diagramme de classe.
2016 page 9
4 PRÉSENTATION DES IMPLÉMENTATION DES CLASSES DU
MODÈLE
4 Présentation des implémentation des classes

du modèle
4.1 Définition des classes

4.1.1 Rôle de la classe Cellule dans l’implémentation de l’AH :
Classe Cellule qui a comme attribut la valeur de type

entier et le type de type chaine de caractère ; le rôle de
cette classe est d’avoir un affichage plus présentable pour
la classe principale Matrhong qui utilise cellule pour créer
une matrice dont chaque case a un couple valeur ,type .
4.1.2 Rôle de la classe Matrhong dans l’implémentation de l’AH :
classe principale implémente les fonctions/les méthodes

suivantes : Comme étape de démarrage ;il s’agit des deux
2016 page 10
MODÈLE
méthodes :
• soustraireminligne(int min)
• soustrairemincolonne(int min)
ces deux méthodes prennent comme argument le
paramètre ‘min’ de type entier ;où il prend la valeur
0 en classe main ; on effet cette étape consiste à
éliminer le plus petit élément de chacune des lignes
puis celui de chacune des colonnes de la matrice par
la comparaison de chaque élément avec le min et le
soustraire de chaque ligne/colonne.
• Ensuite la méthode : encadrerzero()

Cette fonction s’intéresse à encadrer les zéros ; en
considérant la ligne ayant un nombre minimal de
zéros et ceci à l’aide du compteur zéros(int). on cadre
l’un des zéros de la ligne puis on barre les zéros qui se
trouvent sur la même ligne ou la même colonne que
le zéro encadré. On procède de même pour toutes les
lignes. Pour éviter de se tromper au niveau du code
on a ajouté la variable doub de type Int qui permet
de ne pas vérifier un zéro s’il est déjà traite ; ça veut
dire si un zéro est déjà valider (doub=1) on le traite
pas encore une fois ; on traite seulement ceux qui ont
doub=0 .
• La méthode Public boolean traitement() :

cette fonction vérifie si la matrice obtenue après les
traitements précédents est optimale ;dans le cas d’op-
timalité il calcule le cout et l’affiche ; sinon il fonc-
tionne selon les étapes suivantes :
— a-marquer les lignes qui ne contiennent aucun zéro
encadre.
— b-marquer toute colonne ayant un zéro barré (non
2016 page 11
MODÈLE
validé) sur une ligne marquée.

— c-marquer toute ligne ayant un zéro encadré dans
une colonne marquée.
On répétant b et c jusqu’au ne plus pouvoir mar-
quer de rangée ; puis met le mot ‘barligne’ dans les
lignes non marquées (ça veut dire les indices qui
ne se trouvent pas dans la liste indiceligne) et le
mot ’barcol’ sur toute colonne marquée(les indices
qui se trouvent dans la liste indicecolonne).
• La méthode public void soutrajout() :

cette méthode permet d’extraire la sous- matrice ob-
tenu puis retranche la valeur de l’élément le plus petit
aux colonnes non barrées et l’ajouter aux lignes bar-
rées.
4.2 L’interface graphique
Dans cette étape nous ferons par ailleurs usage de

la bibliothèque de composants Swing pour implémenter
cette interface ci-dessus :
Figure 2 – fenêtre d’accueil où on saisie la taille de la matrice NXN .
2016 page 12
MODÈLE
Figure 3 – fenêtre pour la saisie des éléments de la matrice.
Figure 4 – fenêtre représentative de la matrice saisie .
2016 page 13
MODÈLE
Figure 5 – fenêtre représentant l’étape de soustraction .
Figure 6 – fenêtre représentant l’étape d’encadrement et l’affichage du coût.
2016 page 14
5 CONCLUSION
5 Conclusion
Dans ce projet, une approche de résolution du pro-

blème d’affectation des ressources avec prise en compte
de leurs compétences et de leurs préférences a été pré-
sentée. Composée de trois étapes ( évaluation des com-
pétences,problème d’affectation, résolution), elle constitue
un système d’affectation performant cherchant d’une part
une meilleure correspondance entre les acquis d’un agent
et les exigences d’une tâche et d’autre part la satisfaction
des préférences des agents.
2016 page 15
RÉFÉRENCES
Bibliographie
Références
[1] R. Faure, B Lemaire, C Picouleau : Précis de recherche

Opérationnelle - 5ème édition Dunod –
[2] Gérard Desbazeille : Exercices et problèmes de re-
cherche opérationnelle - 2éme édition Dunod
[3] https ://tel.archives-ouvertes.fr/file/index/docid/55124/filename/theseDrag
http ://www.cherchez.me/search/Algorithme : :Hon-
grois/pdf/1
[4] Algorithm for the assignment and transportation pro-
blems,J. Munkres,J. SIAM
Vol. 5, pages 32–38, 1957
2016 page 16
6 ANNEXE
6 Annexe
6.1 Classe Cellule
public class cellule{

int valeur;// pour la valeur de l'element
String type;// le type de l'element (encadre ou non)
//constructeur
public cellule(int valeur,String type)
{
this.valeur=valeur;
this.type=type;
}
//pour modifier le type de l'element
public void changereType(String type){
this.type=type;
}
//pour changer la valeur de l'element
public void changerValeur(int valeur){
this.valeur=valeur;
}
//pour l'affichage du couple(valeur,type)
public String toString(){
return "{"+valeur+","+type+"}";
}
//pour la copie de chaque cellule
public cellule clone(){
return new cellule(this.valeur,this.type);
}
}
6.2 Classe Matrhong :
public class matrhong

{
static int dimension;//dimension de la matrice.
cellule[][] tablecellule;// matrice dont le traitement va
etre appliquer.
2016 page 17
6 ANNEXE
cellule[][] origine;// matrice saisie au debut pour calculer

le cout a la fin.
List <Integer> indiceligne;//liste pour les indices des
lignes non_barrees.
List <Integer> indicecolonne;//liste pour les indices des
colonnes barrees.
//constructeur
public matrhong(int dimension){
this.dimension=dimension;
tablecellule=new cellule[dimension][dimension];
Scanner in = new Scanner(System.in);
for(int i=0;i<dimension;i++){
for(int j=0;j<dimension;j++){
tablecellule[i][j] =new cellule( rand.
nextInt(30),"");
}}
copie();
}
//la copie de la matrice saisie dans origine .

public void copie(){
origine = new cellule[dimension][dimension];
for (int i = 0; i <dimension; i++){
for (int j = 0; j <dimension; j++){
origine[i][j] =tablecellule[i][j].clone();
}}}
affichage de la matrice saisie
//Affichage de la matrice saisie.

public String toString(){
String s="[";
s+=tablecellule[i][j].toString()+" ";
}
s+="\n";
}
return s+"]";
}
-Recherche du min ligne et le soustraire : Paramètre : min pour le comparer avec
les valeurs introduites dans la matrice saisie et enfin relever le minimum et le soustraire
des éléments de la même ligne. Complexité :O(n3)pour chaque ligne on doit faire n
opérations pour calculer et n opérations pour la soustraction .
2016 page 18
6 ANNEXE
//La recherche du minimum dans chaque ligne et le soustraire de la meme

ligne.
public void soustraireminlgne(int min){
System.out.println("recherche min par ligne :");
for ( int i = 0 ; i <dimension ; i++ ){
min = tablecellule[i][0].valeur;
for ( int j = 0 ; j <dimension ; j++ ){
if(min>tablecellule[i][j].valeur)
min=tablecellule[i][j].valeur;
}
for (int j = 0 ; j <dimension; j++ ){
tablecellule[i][j].valeur−=min;
}
System.out.println("min de ligne "+i+" est:"+min
);
}
for (int j = 0 ; j < dimension ; j++ ) {
System.out.print("\t"+tablecellule[i][j
]);
}
System.out.println();
}}
-Recherche min colonne et le soustraire : Détails : recherche du minimum dans
chaque colonne et le soustraire. Argument : min->en main on lui a attribué la valeur
0 pour la comparaison et la récupération du min . Complexite :O(n2)pour chaque
colonne on doit faire n opérations pour calculer et n opérations pour la soustraction .
public void soustrairemincolonne(int min) {

System.out.println("recherche min par colonne :");
for ( int j = 0 ; j < dimension ; j++ ) {
min = tablecellule[0][j].valeur;
for ( int i = 0 ; i< dimension ; i++ ) {
if(min>tablecellule[i][j].valeur)
min=tablecellule[i][j].valeur;
}
}
System.out.println("min de colonne "+j+" est:"
+min);
}
for ( int i = 0 ; i < dimension ; i++ ){
for (int j = 0 ; j <dimension ; j++ ){
2016 page 19
6 ANNEXE
]);
}
}}
-Traitement : encadrer les zéros sélectionnés et non sélectionnés.
«V» : pour les zéros validés (encadré).
«NV» : pour les zéros non validés (non encadré).
Complexité :O(n3)recherche pour chaque ligne et chaque colonne et sélectionne-

ment de zéro.
//Etape d'encadrement
public void encadrerzero(){
int doub=0;//pour le traitement des zeros deja traites
int zeros=0;//compteur des zeros
int numligne=0 ;//l'indice de la ligne du zero encadre
int numcolonne=0;//l'indice de la colonne du zero encadre
for(int i=0;i<dimension;i++) {
zeros=0;
for(int j=0;j<dimension;j++) {
if(tablecellule[i][j].valeur==0)zeros
++;
}
if(zeros==1) {
numligne=i;
if(tablecellule[i][j].valeur==0)
{
numcolonne=j;
tablecellule[numligne][numcolonne].
changereType("V");
} }}
if(tablecellule[numligne][j].valeur==0
&& j!=numcolonne) {
tablecellule[numligne][j].valeur
=−1;
System.out.println("nn ecadrer "
+numligne+" "+j);
tablecellule[numligne][j].
changereType("NV");
}}
if(tablecellule[j][numcolonne].valeur
==0 && j!=numligne) {
tablecellule[j][numcolonne].
2016 page 20
6 ANNEXE
valeur=−1;
System.out.println("nn ecadrer "
+j+" "+numcolonne);
changereType("NV");
}}}
if(tablecellule[i][j].valeur==−1)
tablecellule[i][j].changerValeur
(0);
}}
//par colonne
zeros=0;
if(tablecellule[j][i].valeur==0)zeros
++;
}
if(zeros==1){
numcolonne=i;
if(tablecellule[j][i].valeur==0) {
numligne=j;
for(int k=0;k<dimension;k++) {
if(tablecellule[numligne][numcolonne].type.
equals("V"))
doub=1;
}
if(doub==0)
tablecellule[numligne][numcolonne].
changereType("V");
}
doub=0;
}
if(tablecellule[numligne][j].valeur==0 && j!=
numcolonne) {
changerValeur(−1);
if(tablecellule[numligne][j].type.equals("NV"))
doub=1;
}
for(int k=0;k<dimension;k++){
if(tablecellule[numligne][j].type
.equals("V"))
2016 page 21
6 ANNEXE
doub=1;
}
if(doub==0)
changereType("NV");
doub=0;
}
}
if(tablecellule[j][numcolonne].valeur==0 && j
!=numligne){
changerValeur(−1);
for(int k=0;k<dimension;k++){
if(tablecellule[j][numcolonne].type.equals
("NV"))
doub=1;
}
if(tablecellule[j][numcolonne].type.equals
("V"))
doub=1;
}
if(doub==0)
changereType("NV");
doub=0;
}
}
}
}
if(tablecellule[i][j].valeur==−1)
tablecellule[i][j].changerValeur
(0);
}}
System.out.println("resultat d'encadrement");
for ( int i = 0 ; i < dimension ; i++ ) {
for (int j = 0 ; j <dimension ; j++ ) {
]);
}
}
}
2016 page 22
6 ANNEXE
le contrôle si la matrice est optimale ou non et le calcul du cout en cas d’optimalité
Détails : cptencadrer->compteur pour calculer le nombre de zéro validé brcol »colonne
barrée , brli »ligne barrée Complexité :O(n2)
public boolean traitement()

{
int cptencadrer=0;
boolean d = false;
List <Integer> indiceligne=new ArrayList<>();
List <Integer> indicecolonne=new ArrayList<>();
for (int j = 0 ; j < dimension ; j++ ){
if(tablecellule[i][j].type.equals("V"))
cptencadrer++;
}}
if(cptencadrer==dimension){
System.out.println("est optimale");
d=true;
int s=0;
for(int i=0;i<dimension;i++) {
for (int j = 0 ; j < dimension ; j++ ) {
if(tablecellule[i][j].type.equals
("V")){
s+=origine[i][j].valeur;
}}}
System.out.println("le cout est :"+s);
}
else {
System.out.println("pas optimale on commence le traitement
par barrer");
for (int i= 0; i <dimension; i++) {
boolean trouve=false;
for (int j= 0; j <dimension; j++){
("V"))
trouve=true;
("NV") && !trouve) {
indiceligne.add(i);
break;
}
else continue;
}}
for (int i= 0; i <dimension; i++){
for (int l= 0; l<indiceligne.size();l++)
{
if(tablecellule[indiceligne.get(
2016 page 23
6 ANNEXE
l)][i].valeur==0) {
indicecolonne.add(i);
} }}
for (int n= 0;n<indicecolonne.size();n++) {
for (int i= 0; i <dimension; i++) {
if(tablecellule[i][indicecolonne.get(n)].type.
equals("V")){
indiceligne.add(i);
}}}
System.out.println("les indices des lignes non
validees\t"+indiceligne.toString())
;
System.out.println("les indices des colonnes
validees\t"+indicecolonne.toString
());
for (int n= 0;n<dimension;n++){
for(int k=0;k<indiceligne.size()
−1;k++){
if (!indiceligne.contains
(n)){
tablecellule[n][i].changereType(tablecellule[n][i].
type+"brli");
} } }}
for (int n= 0;n<dimension;n++){
for(int k=0;k<indicecolonne.
size();k++) {
if (indicecolonne.
contains(n)){
tablecellule[i][n].changereType(tablecellule[i][n].type
+"brcol");
}}}}
for ( int i = 0 ; i < dimension ; i++ ) {
for (int j = 0 ; j <dimension ; j++ ) {
System.out.print("\t"+
tablecellule[i][j]);
}
}
soutrajout();
}
return d;
}
-Recherche du min dans la sous-matrice et la soustraction et l’addition : Détails :
2016 page 24
6 ANNEXE
recherche de la sous-matrice ; soustraire le min de cet sous matrice des éléments non
barrée et l’ajout pour le croisement (explication ci-dessous). Complexité :O(n2) le
parcours de chaque ligne et chaque colonne pour relever le min et O(n2) encore une
fois le parcours pour la soustraction et O(n2)encore une fois pour l’addition Ceci donne
O(n2).
public void soutrajout() {

int min=30;
for ( int i = 0 ; i< dimension ; i++ ){
for (int j = 0 ; j<dimension ; j++ ){
if(tablecellule[i][j].type.equals("")) {
if(tablecellule[i][j].valeur<min)
{
min=tablecellule[i][j].
valeur;
} } }}
if(tablecellule[i][j].type.equals("")) {
}}}
if(tablecellule[i][j].type.equals("
brlibrcol")||tablecellule[i][j].type.
equals("NVbrlibrcol")||tablecellule
[i][j].type.equals("Vbrlibrcol")){
tablecellule[i][j].valeur+=min;
} }}
System.out.println("apres soustraire et l'ajout du min");
for ( int i1 = 0 ; i1 < dimension ; i1++ ){
for (int j1 = 0 ; j1 <dimension ; j1++ ){
System.out.print("\t"+tablecellule[i1][
j1]);
}
}
tablecellule[i][j].changereType("");
} }}//fin de la fonction soustrajout() .
}//fin de la classe Matrhong.
2016 page 25
6 ANNEXE
6.3 Classe main :
Class main où on fait l’appel des fonctions définissaient au niveau de la classe «Ma-
trhong» : Variables :cpt->compteur pour calculer le nombre de fois la non-optimalité

de la matrice saisie .
public class main{

private static int n;
public static void main(String[] args){
Scanner in = new Scanner(System.in);

System.out.println("Enter nombre de ligne et de colonne");
n = in.nextInt();
matrhong mat=new matrhong(n);
System.out.println(mat);
mat.copie();
mat.soustraireminlgne(0);
mat.soustrairemincolonne(0);
mat.encadrerzezo();
int cpt=0;
while(mat.traitement()==false) {
mat.encadrerzezo();
cpt++;
si le compteur est supérieur que 4 fois on arrête le traitement et on affiche que la

matrice n’est pas optimale pour toujours.
if(cpt>4){
System.out.println("cette matrice pas
optimal");
break;
}
}}
}
//fin de classe main
6.4 Classe interface :
import javax.swing.∗;
import java.awt.∗;
2016 page 26
6 ANNEXE
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class hsd extends JFrame implements ActionListener{

CardLayout pile;//Gestionnaire de placement des composants en
forme de pile.
JTextField champ;
JTextField[][] table;
JScrollPane pann3;
JPanel panneau3,panneau1_2,panneauPri,panneau5,panneau5_1,
panneau8;
JEditorPane panneau4,panneau6,panneau7;
Container c;
JButton Entrer,rechercher,suiv,suiv3,b,suiv1;
matrhong r;
cellule[][] tabl;//pour la copie de ce qu'on a saisie.
public hsd(){
super(" −− Projet : Implementation,simulation et test de l'
algorithme Hongrois en JAVA −−");//titre de la fenetre.
ImageIcon edit=new ImageIcon("LogoFsr.png");//l'icone de
la fenetre.
this.setIconImage(edit.getImage());
c = this.getContentPane();//container principal.
Visual();//la methode visual.
}
public JPanel Visual(){
panneau4=new JEditorPane();
panneau4.setContentType("text/html");
panneau4.setEditable(false);
panneau4.setBackground(new Color(67, 173, 195, 1));
panneau4.setText("<h1><b><center>
Implementation, simulation et test de l'algorithme
Hongrois en JAVA    </center></b
></h1>"
+ "<p><h2><center><u>Presente par :
</u></center></h2>"
+ "<h3><center>ABBAD ASMAA ET AIT
MANSOUR GHIZLANE</center></
h3></p><br><br>");
panneauPri=new JPanel();//panneau global.

panneauPri.setLayout(new BorderLayout());
panneauPri.add(panneau4, BorderLayout.NORTH);
JPanel p=new JPanel();

//saisie de la taille de la matrice.
JLabel l=new JLabel("Entrez la taille du matrice : ",JLabel
.RIGHT);
champ=new JTextField(20);
p.setLayout(new BorderLayout());
2016 page 27
6 ANNEXE
//panneau dont on insere l'etiquette.

JPanel pp1=new JPanel();
//panneau dont on insere le champ texte de la saisie.
JPanel pp2=new JPanel();
p.add(pp1,BorderLayout.NORTH);
p.add(pp2,BorderLayout.CENTER);
pp2.add(l);
pp2.add(champ);
JPanel p1=new JPanel();
Entrer=new JButton("valider");
Entrer.addActionListener(this);
p1.add(Entrer);
//l'insertion des panneaux dans le panneau global.
panneauPri.add(p, BorderLayout.CENTER);
panneauPri.add(p1, BorderLayout.SOUTH);
pile = new CardLayout();
c.setLayout(pile);
c.add(panneauPri);
this.setSize(800, 350);
setResizable(false);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(3);
return panneauPri;
}
public void actionPerformed(ActionEvent ev) {
int taille=0;
try{
taille=Integer.parseInt(champ.getText());
}
catch(Exception e){
JOptionPane.showMessageDialog(this, "Entrez la
taille de type Int","Erreur",0);
}
if(ev.getSource()==Entrer){
panneau6.setBackground(new Color(197, 181, 181,
1));
panneau6.setText("<h1><b><center> &
nbsp; Implementation, simulation et test
de l'algorithme Hongrois en JAVA &nbsp
; </center></b></h1>"
+ "<h2><center><u>Entrez les
elements : </u></center></h2
>");
panneau3=new JPanel();
panneau3.setLayout(new GridLayout(taille,
2016 page 28
6 ANNEXE
taille));
panneau3.setBorder(BorderFactory.
createEmptyBorder(30,40,40,20));
table=new JTextField[taille][taille];
for(int i=0;i<taille;i++){
for(int j=0;j<taille;j++){
table[i][j]=new JTextField(15);
panneau3.add(table[i][j]);
}
}
pann3=new JScrollPane(panneau3);
panneau5_1=new JPanel();
rechercher=new JButton("Debut de traitement");
rechercher.addActionListener(this);
panneau5_1.add(rechercher);
panneau5.setLayout(new BorderLayout());
panneau5.add(panneau6, BorderLayout.NORTH);
panneau5.add(pann3, BorderLayout.CENTER);
panneau5.add(panneau5_1, BorderLayout.SOUTH);
c.add(panneau5);
pile.next(c);
}
//l'action sur le bouton rechercher
if(ev.getSource()==rechercher){
Integer[][] table1=new Integer[taille][taille];
cellule[][] tab = null;
try{
table1[i][j]=Integer.
parseInt(table[i][j].
getText());
}
catch(Exception e){
JOptionPane.
showMessageDialog
(this, "Entrez
les elements de
type Int","
Erreur",0);
}}}
1));
2016 page 29
6 ANNEXE
; </center></b></h1>"
+ "<h2><center><u>La matrice
saisie : </u></center></h2>"
);
JPanel pan=new JPanel();
c.add(panneau8);
pile.next(c);
r=new matrhong(taille,table1);
r.copie();
pan.setLayout(new GridLayout(taille,taille));
panneau8.add(pan, BorderLayout.CENTER);
JPanel pann=new JPanel();
panneau8.add(pann, BorderLayout.SOUTH);
JLabel ress=new JLabel("");
pann.add(ress);
suiv=new JButton("suivant");
suiv.addActionListener(this);
pann.add(suiv);
tabl=r.table();
b= new JButton(""+tabl[i][j]);
b.setBackground(Color.white);
b.setPreferredSize(new Dimension(200,20));
pan.add(b);
}}}
//action sur le bouton suiv.
if(ev.getSource()==suiv){
1));
; </center></b></h1>"
+ "<h2><center><u>Etape 1 : </
u></center></h2>");
c.add(panneau8);
pile.next(c);
JPanel pan2=new JPanel();
JLabel res=new JLabel("");
2016 page 30
6 ANNEXE
pan.setLayout(new GridLayout(1,2));
panneau8.add(pan2, BorderLayout.SOUTH);
suiv3=new JButton("Suivant");
suiv3.addActionListener(this);
pan2.add(res);
pan3.setLayout(new GridLayout(2,1));
JSplitPane pann=new JSplitPane(JSplitPane.
HORIZONTAL_SPLIT,pan3,pan4);
pan.add(pann);
JLabel txt1=new JLabel("<html><p>  &
nbsp; Soustraire l'element minimal pour
chaque ligne :</p></html>");
pan3.add(txt1);
JLabel txt2=new JLabel("<html><p>  &
nbsp; Soustraire l'element minimal pour
chaque colonne :</p></html>");
pan4.add(txt2);
JLabel t1=new JLabel();
JLabel t2=new JLabel();
pan3.add(t1);
pan4.add(t2);
pan2.add(suiv3);
t1.setLayout(new GridLayout(taille,taille));
t2.setLayout(new GridLayout(taille,taille));
r.soustraireminlgne(0);
tabl=r.table();
if(tabl[i][j].type.equals("V"))
b.setForeground(Color.blue);
if(tabl[i][j].type.equals("NV"))
b.setForeground(Color.red);
t1.add(b);
}}
r.soustrairemincolonne(0);
tabl=r.table();
2016 page 31
6 ANNEXE
t2.add(b);
}
}}
if(ev.getSource()==suiv3){
1));
; </center></b></h1>"
+ "<h2><center><u>Resultat d'
encadrement : </u></center
></h2>");
c.add(panneau8);
pile.next(c);
suiv1=new JButton("Suivant");
suiv1.setVisible(false);
suiv1.addActionListener(this);
pan2.add(res);
pan2.add(suiv1);
r.soustraireminlgne(0);
r.soustrairemincolonne(0);
r.encadrerzezo();
tabl=r.table();
pan.add(b);
}}
r.traitement();
if(r.traitement()==true){
res.setText(r.getres()+"\n"+r.getopt());
2016 page 32
6 ANNEXE
}
else{
res.setText(r.getres());
suiv1.setVisible(true);
}
}
if(ev.getSource()==suiv1){
1));
; </center></b></h1>"
+ "<h2><center><u>
Traitement : </u></
center></h2>");
c.add(panneau8);
pile.next(c);
pan2.add(res);
r.traitement();
int cpt=0;
while(r.traitement()==false) {
r.encadrerzezo();
cpt++;
if(cpt>4) {
res.setText("cette matrice pas
optimal");
break;
}}
tabl=r.table();
2016 page 33
6 ANNEXE
pan.add(b);
}}
if(r.traitement()==true){
res.setText(r.getres()+r.getopt());
}}}
public static void main(String[] args){
new hsd();
}
}
2016 page 34

Sdic PL0277

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Sdic PL0277

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITÉ MOHAMMED V de Rabat

Faculté des Sciences

PROJET DE FIN D’ÉTUDES

Implémentation, test et simulation de

M.El AMRANI Younés Professeur à la Faculté des Sciences - Rabat Encadrant

— Nous tenons aussi à remercier vivement les membres

— Nous souhaitons aussi envoyer nos sincères remercie-

Ce projet consiste l’implémentation en java de l’al-

Ce travail a pour but de résoudre le problème d’af-

Mots clés : JAVA,COUT,RECHERCHE OPÉRA-

The main objective of this project involves the im-

Keywords JAVA,COST,OPERATIONAL RE-

3 Diagramme de classe :vue générale 9

4 Présentation des implémentation des

La plupart des algorithmes proposés pour le pro-

Algorithme HONGROIS :Présentation

où c représente le coût de la paire (a, b). Cet algorithme

telle qu’on minimise :

cet algorithme consisterait à calculer, pour chaque assigne-

Réduction des lignes : on crée une nouvelle matrice

Réduction des colonnes : on crée une nouvelle matrice des

Maintenant, il faut déterminer le nombre minimal de

Dans ce cas, le nombre minimal de zéro est de 3 qui est

La valeur minimum des cellules non couvertes est 20. On

Maintenant, le nombre minimal de ligne est égale à 4.

La solution optimale est donc la suivante :

La solution à pour coût :

60 + 200 + 180 + 90 = 530

3 Diagramme de classe :vue générale

Figure 1 – Diagramme de classe.

4 Présentation des implémentation des classes

4.1 Définition des classes

Classe Cellule qui a comme attribut la valeur de type

4.1.2 Rôle de la classe Matrhong dans l’implémentation de l’AH :

classe principale implémente les fonctions/les méthodes

• Ensuite la méthode : encadrerzero()

• La méthode Public boolean traitement() :

validé) sur une ligne marquée.

• La méthode public void soutrajout() :

4.2 L’interface graphique

Dans cette étape nous ferons par ailleurs usage de

Figure 2 – fenêtre d’accueil où on saisie la taille de la matrice NXN .

Figure 3 – fenêtre pour la saisie des éléments de la matrice.

Figure 4 – fenêtre représentative de la matrice saisie .

Figure 5 – fenêtre représentant l’étape de soustraction .

Figure 6 – fenêtre représentant l’étape d’encadrement et l’affichage du coût.

Dans ce projet, une approche de résolution du pro-

[1] R. Faure, B Lemaire, C Picouleau : Précis de recherche

6.1 Classe Cellule

public class cellule{

6.2 Classe Matrhong :

public class matrhong

cellule[][] origine;// matrice saisie au debut pour calculer

//la copie de la matrice saisie dans origine .

affichage de la matrice saisie

//Affichage de la matrice saisie.

-Recherche du min ligne et le soustraire : Paramètre : min pour le comparer avec

opérations pour calculer et n opérations pour la soustraction .

//La recherche du minimum dans chaque ligne et le soustraire de la meme

-Recherche min colonne et le soustraire : Détails : recherche du minimum dans

chaque colonne et le soustraire. Argument : min->en main on lui a attribué la valeur

0 pour la comparaison et la récupération du min . Complexite :O(n2)pour chaque

colonne on doit faire n opérations pour calculer et n opérations pour la soustraction .