Algorithme de Ford
Lourdel Nicolas
Sergent Nicolas
Juin 2019
Table des matières
I.
Théorie des graphes .......................................................................................................................... 3
a)
Définition .............................................................................................................................................. 3
b)
Origines ................................................................................................................................................. 4
II.
Algorithme ........................................................................................................................................ 6
c)
Définition d’un algorithme .................................................................................................................... 6
d)
Définition générale ............................................................................................................................... 6
e)
Quelques définitions connexes : ........................................................................................................... 7
f)
Algorithme numérique.......................................................................................................................... 8
g)
Algorithme non numérique .................................................................................................................. 8
h)
Algorithme dans la vie quotidienne ...................................................................................................... 8
III.
i)
Recherche du chemin le plus court............................................................................................. 10
Algorithme utilisé ................................................................................................................................ 10
IV.
Implémentation de l’algorithme ................................................................................................. 12
j)
Choix du langage ................................................................................................................................. 12
k)
Traduction du problème ..................................................................................................................... 12
l)
Traduction du graphe en langage informatique ................................................................................. 12
m)
V.
Traduction de l’algorithme ............................................................................................................. 14
Interface Graphique ........................................................................................................................ 16
n)
Description et utilisation de l’application ........................................................................................... 16
o)
Conclusion ........................................................................................................................................... 17
I. Théorie des graphes
a)
Définition
La théorie des graphes est la discipline mathématique et informatique qui
étudie les graphes, lesquels sont des modèles abstraits de dessins de
réseaux reliant des objets1. Ces modèles sont constitués par la donnée de
sommets (aussi appelés nœuds ou points, en référence aux polyèdres), et
d'arrêtes (aussi appelées liens ou lignes) entre ces sommets ; ces arêtes
sont parfois non-symétriques (les graphes sont alors dits orientés) et sont
appelés des flèches.
Les algorithmes élaborés pour résoudre des problèmes concernant les
objets de cette théorie ont de nombreuses applications dans tous les
domaines liés à la notion de réseau (réseau social, réseau informatique,
télécommunications, etc.) et dans bien d'autres domaines (par exemple
génétique) tant le concept de graphe, à peu près équivalent à celui de
relation binaire (à ne pas confondre donc avec graphe d'une fonction), est
général. De grands théorèmes difficiles, comme le théorème des quatre
couleurs, le théorème des graphes parfaits, ou encore le théorème de
Robertson-Seymour, ont contribué à asseoir cette matière auprès des
mathématiciens, et les questions qu'elle laisse ouvertes, comme la
conjecture de Hadwiger, en font une branche vivace des mathématiques
discrètes.
b)
Origines
Un article du mathématicien suisse Leonhard Euler, présenté à l'Académie
de Saint-Pétersbourg en 1735 puis publié en 1741, traitait du problème des
sept ponts de Königsberg, ainsi que schématisé ci-dessous. Le problème
consistait à trouver une promenade à partir d'un point donné qui fasse
revenir à ce point en passant une fois et une seule par chacun des sept
ponts de la ville de Königsberg. Un chemin passant par toute arête
exactement une fois fut nommé chemin eulérien, ou circuit eulérien s'il finit
là où il a commencé. Par extension, un graphe admettant un circuit eulérien
est dit graphe eulérien, ce qui constitue donc le premier cas de propriété
d'un graphe. Euler avait formulé7 qu'un graphe n'est eulérien que si chaque
sommet a un nombre pair d'arêtes. L'usage est de s'y référer comme
théorème d'Euler, bien que la preuve n'en ait été apportée que 130 ans plus
tard par le mathématicien allemand Carl Hierholzer. Un problème similaire
consiste à passer par chaque sommet exactement une fois, et fut d'abord
résolu avec le cas particulier d'un cavalier devant visiter chaque case d'un
échiquier par le théoricien d'échecs arabe Al-Adli dans son ouvrage
Kitabash-shatranj paru vers 840 et perdu depuis. Ce problème du cavalier
fut étudié plus en détail au XVIII siècle par les mathématiciens français
Alexandre-Théophile Vandermonde, Pierre Rémond de Montmort et
Abraham de Moivre; le mathématicien britanniqueThomas Kirkman étudia
le problème plus général du parcours où on ne peut passer par un sommet
qu'une fois, mais un tel parcours prit finalement le nom de chemin
hamiltonien d'après le mathématicien irlandaisWilliam Rowan Hamilton, et
bien que ce dernier n'en ait étudié qu'un cas particulier. On accorde donc à
Euler l'origine de la théorie des graphes parce qu'il fut le premier à
proposer un traitement mathématique de la question, suivi par
Vandermonde.
e
Un des problèmes les plus connus de théorie des graphes vient de la
coloration de graphe, où le but est de déterminer combien de couleurs
différentes suffisent pour colorer entièrement un graphe de telle façon
qu'aucun sommet n'ait la même couleur que ses voisins. En 1852, le
mathématicien sud-africain Francis Guthrie énonça le problème des quatre
couleurs par une discussion à son frère, qui demandera à son professeur
Auguste De Morgan si toute carte peut être coloriée avec quatre couleurs
de façon que des pays voisins aient des couleurs différentes. De Morgan
envoya d'abord une lettre au mathématicien irlandais William Rowan
Hamilton, qui n'était pas intéressé, puis le mathématicien anglais Alfred
Kempe publia une preuve erronée dans l’American Journal of Mathematics,
qui venait d'être fondé par Sylvester. L'étude de ce problème entraîna de
nombreux développements en théorie des graphes, par Peter Guthrie Tait,
Percy John Heawood, Frank Ramsey et Hugo Hadwiger.
Les problèmes de factorisation de graphe émergèrent ainsi à la fin du
XIXe siècle en s'intéressant aux sous-graphes couvrants, c'est-à-dire aux
graphes contenant tous les sommets mais seulement une partie des arêtes.
Un sous-graphe couvrant est appelé un k-facteur si chacun de ses sommets
a k arêtes et les premiers théorèmes furent donnés par Julius Petersen ; par
exemple, il montra qu'un graphe peut être séparé en 2-facteurs si et
seulement si tous les sommets ont un nombre pair d'arêtes (mais il fallut
attendre 50 ans pour que Bäbler traite le cas impair). Les travaux de
Ramsey sur la coloration, et en particulier les résultats du mathématicien
hongrois Pal Turan, permirent le développement de la théorie des graphes
extrémaux s'intéressant aux graphes atteignant le maximum d'une quantité
particulière (par exemple le nombre d'arêtes) avec des contraintes
données, telles que l'absence de certains sous-graphes.
Dans la seconde moitié du XXe siècle, le mathématicien français Claude
Berge contribue au développement de la théorie des graphes par ses
contributions sur les graphes parfaits et l'introduction du terme
d’hypergraphe (suite à la remarque de Jean-Marie Pla l'ayant utilisé dans un
séminaire) avec un monographe sur le sujet. Son ouvrage d'introduction à
la théorie des graphes proposa également une alternative originale,
consistant plus en une promenade personnelle qu'une description
complète. Il marquera également la recherche française en ce domaine, par
la création conjointe avec Marcel-Paul Schützenberger d'un séminaire
hebdomadaire à l'Institut Henri Poincaré, des réunions le lundi à la Maison
des Sciences de l'Homme, et la direction de l'équipe Combinatoire de Paris
II. Algorithme
c) Définition d’un algorithme
Un algorithme est une suite finie et non ambiguë d’opérations ou
d'instructions permettant de résoudre une classe de problèmes.
Le mot algorithme vient du nom d'un mathématicien perse du IXe siècle, AlKhwârizmî.Le domaine qui étudie les algorithmes est appelé
l'algorithmique. On retrouve aujourd'hui des algorithmes dans de
nombreuses applications telles que le fonctionnement des ordinateurs, la
cryptographie, le routage d'informations, la planification et l'utilisation
optimale des ressources, le traitement d'images, le traitement de texte, la
bio-informatique, etc.
d)
Définition générale
Un algorithme est une méthode générale pour résoudre un type de
problèmes. Il est dit correct lorsque, pour chaque instance du problème, il
se termine en produisant la bonne sortie, c'est-à-dire qu'il résout le
problème posé. On mesure l'efficacité d'un algorithme notamment par sa
durée de calcul, par sa consommation de mémoire vive (en partant du
principe que chaque instruction a un temps d'exécution constant), par la
précision des résultats obtenus (par exemple avec l'utilisation de méthodes
probabilistes), sa scalabilité (son aptitude à être efficacement parallélisé),
etc. Les ordinateurs sur lesquels s'exécutent ces algorithmes ne sont pas
infiniment rapides : le temps de machine reste une ressource limitée,
malgré une augmentation constante des performances des ordinateurs. Un
algorithme sera donc dit performant s'il utilise avec parcimonie les
ressources dont il dispose, c'est-à-dire le temps CPU, la mémoire vive et
(aspect objet de recherches récentes) la consommation électrique.
L’analyse de la complexité algorithmique permet de prédire l'évolution en
temps calcul nécessaire pour amener un algorithme à son terme, en
fonction de la quantité de données à traiter
e)Quelques définitions connexes :
Donald Knuth (1938-) liste, comme prérequis d'un algorithme, cinq
propriétés :
Finitude : « Un algorithme doit toujours se terminer après un nombre fini
d’étapes. »
Définition précise : « Chaque étape d'un algorithme doit être définie
précisément, les actions à transposer doivent être spécifiées
rigoureusement et sans ambiguïté pour chaque cas. »
Entrées : « […] des quantités qui lui sont données avant qu'un algorithme
ne commence. Ces entrées sont prises dans un ensemble d'objets
spécifié. »
Sorties : « […] des quantités ayant une relation spécifiée avec les entrées. »
Rendement : « […] toutes les opérations que l'algorithme doit accomplir
doivent être suffisamment basiques pour pouvoir être en principe réalisées
dans une durée finie par un homme utilisant un papier et un crayon. »
George Boolos (1940-1996), philosophe et mathématicien, propose la
définition suivante5 :
« Des instructions explicites pour déterminer le nième membre d'un
ensemble, pour n un entier arbitrairement grand. De telles instructions sont
données de façon bien explicite, sous une forme qui puisse être utilisée par
une machine à calculer ou par un humain qui est capable de transposer des
opérations très élémentaires en symboles. »
Gérard Berry (1948-), chercheur en science informatique en donne la
définition grand public suivante6 :
« Un algorithme, c’est tout simplement une façon de décrire dans ses
moindres détails comment procéder pour faire quelque chose7. Il se trouve
que beaucoup d’actions mécaniques, toutes probablement, se prêtent bien
à une telle décortication. Le but est d’évacuer la pensée du calcul, afin de le
rendre exécutable par une machine numérique (ordinateur…). On ne
travaille donc qu’avec un reflet numérique du système réel avec qui
l’algorithme interagit. »
f) Algorithme numérique
Les algorithmes sont des objets historiquement dédiés à la résolution de
problèmes arithmétiques, comme la multiplication de deux nombres. Ils ont
été formalisés bien plus tard avec l'avènement de la logique mathématique
et l'émergence des machines qui permettaient de les mettre en œuvre, à
savoir les ordinateurs.
g)
Algorithme non numérique
La plupart des algorithmes ne sont pas numériques.
On peut distinguer :
Des algorithmes généralistes qui s'appliquent à toute donnée numérique ou
non numérique : par exemple les algorithmes liés au chiffrement, ou qui
permettent de les mémoriser ou de les transmettre ;
Des algorithmes dédiés à un type de données particulier (par exemple ceux
liés au traitement d'images).
h)
Algorithme dans la vie quotidienne
L'algorithmique intervient dans la vie de tous les jours.
Une recette de cuisine peut être réduite à un algorithme si on peut réduire
sa spécification aux éléments constitutifs :
Des entrées (les ingrédients, le matériel utilisé).
Des instructions élémentaires simples (frire, flamber, rissoler, braiser,
blanchir, etc.), dont les exécutions dans un ordre précis amènent au
résultat voulu.
Un résultat : le plat préparé.
Cependant, les recettes de cuisine ne sont en général pas présentées
rigoureusement sous forme non ambiguë : il est d'usage d'y employer des
termes vagues laissant une liberté d'appréciation à l'exécutant alors qu'un
algorithme non probabilistestricto sensu doit être précis et sans ambiguïté.
Le tissage, surtout tel qu'il a été automatisé par le métier Jacquard est une
activité que l'on peut dire algorithmique.
Un casse-tête, tel le Rubik's Cube, peut être résolu de façon systématique
par un algorithme qui mécanise sa résolution.
En sport, l'exécution de séquences répondant à des finalités d'attaque, de
défense, de progression, correspond à des algorithmes (dans un sens assez
lâche du terme). Voir en particulier l'article tactique (football).
En soins infirmiers, le jugement clinique est assimilable à un algorithme. Le
jugement clinique désigne l'ensemble des processus cognitifs et
métacognitifs qui aboutissent au diagnostic infirmier. Il met en jeu des
processus de pensée et de prise de décision dans le but d’améliorer l’état
de santé et le bien-être des personnes que les soignants accompagnent.
Un code juridique, qui décrit un ensemble de procédures applicables à un
ensemble de cas, est un algorithme.
III. Recherche du chemin le plus court
i) Algorithme utilisé
Poids des arcs
Le problème et ses solutions dépendent d'abord de la nature des poids :
chaque arc (x,y)est doté d'un poids(x,y)qui est un nombre réel. Les
différents cas considérés sont :
Les poids sont tous positifs : Dans ce cas, l'algorithme de Dijkstra permet de
résoudre le problème du plus court chemin d'un sommet donné aux autres
sommets en complexité en temps O(m + n log n)Pour un graphe à n arcs et
msommets.
Les poids sont quelconques, mais il n'y a pas de circuit de poids négatif (pas
de circuit absorbant) : Dans ce cas, l'algorithme de Bellman-Ford permet de
tester s'il existe un circuit absorbant et, en absence d'un tel circuit, de
trouver un plus court chemin en temps O(nm).
Les poids sont quelconques : Cette variante est NP-difficile, comme on peut
le voir en considérant la réduction du problème du chemin hamiltonienNPcomplet qui consiste à fixer le poids des arcs à -1.
Algorithme utilisé
Dans notre problème ou les arcs représentent des distances, les poids sont
tous positifs, l’algorithme de Dijkstra apparaît donc comme le plus
commode pour résoudre ce problème.
Cependant c’est une variante de l’algorithme de Bellman-Ford, sans
recherche de la présence d’un circuit absorbant, que nous avons choisi de
présenter pour résoudre ce problème.
Cet algorithme peut aussi bien servir à trouver le chemin le plus court
comme le chemin le plus long.
Algorithme de Bellman-Ford
Cet algorithme peut se décrire de la manière suivante :
Initialisation :
On numérote de manière quelconque les sommets, x(o), x(i), x(n), x(o)
est le départ et x(n-1) est l’arrivée.
On affecte au sommet du graphe un poids nul x(o) = 0 et à tout les
autres sommets x(i) un poids infini.
Itération :
Pour tout sommet x(j) :
Si λ(j) – λ(i) > V(x(i), x(j))
Alors λ(j) = λ(i) + V(x(i), x(j))
Sinon λ(j) inchangé
Condition de fin :
Continuer l’itération jusqu’à ce qu’on ne puisse plus diminuer λ(j)
IV. Implémentation de l’algorithme
j) Choix du langage
Pour ce projet nous avons décidé de développer notre application en Java. De plus on a utilisé la librairie
java Swing et le plugin Windows Builder.
Java est très utile pour de petites applications simples, notamment grâce à
ces librairies graphiques et ses plugins.
Window Builder est un plugin Java qui propose une interface graphique
pour construire la partie visuelle de notre application. Grâce à cette
interface, l’usage des objets proposés par la librairie graphique swing et
simplifiée en particulier le placement de ses éléments et la gestion des
évènements qui leur sont lies.
k)
Traduction du problème
Le programme que nous avons réalisé permet de calculer le chemin le plus
court entre une ville de départ et une ville d’arrivée.
Le graphe sur lequel va travailler notre algorithme a pour sommets des
villes et pour arcs les routes entre ces villes dont le poids représente la
distance entre ces villes.
l) Traduction du graphe en langage informatique
Comment représenter, programmer ces villes, ces routes et ces distances
en langage informatique ?
Nous avons utilisé la Programmation Orienté Objet (POO) pour traduire ce
graphe en langage informatique.
Les villes ont été modélisés dans un format générique, un objet, ici une
classe java appelée Ville possédant des attributs.
/*
* @ Object : Ville, ville .
* @ Param : poids, valeur du poids associé à un sommet, par défaut il
est infini.
* @ Param : bouton, bouton cliquable présent sur la carte auquel est
associé la ville
* @ Param : nom, nom de la ville.
* @ Param : villeDest, Liste des villes de destination possibles et
la distance de celles ci.
* @ Param : villeOrigine, ville par laquelle est passée l'algorithme
pour calculer un chemin.
*/
public class Ville {
public int poids = Integer.MAX_VALUE;
publicJRadioButton bouton;
public String nom;
publicMap<Ville, Integer>villesDest = new HashMap<Ville,
Integer>();
public Ville villeOrigine;
…
}
Chaque ville possède un poids, un bouton associé présent sur l’interface
utilisateur et un nom.
Elle possède également :
Une liste clé, valeur : Définie de façon arbitraire, elle représente les
villes adjacentes vers lesquelles ont peut se rendre à partir de la ville
donnée, la clé est un sommet, une ville donc, et la valeur représente
le poids de l’arc entre ces deux villes, arc orienté vers la ville de
destination, soit la route pour se rendre à cette ville et sa longueur.
Une ville d’origine : Cette ville d’origine est la ville à partir de laquelle
l’algorithme est passé pour calculer le nouveau poids de la ville. Cette
ville n’existe pas tant que l’algorithme ne s’est pas exécuté et peut
changer durant le calcul et d’un calcul à un autre.
Durant le calcul l’algorithme peut affecter un nouveau poids à une
ville, inférieur au précédant, en passant par une ville différente, il va
donc changer la ville d’origine de cette ville. A la fin, de la ville
d’arrivée à la ville adjacente à la ville de départ, toutes les villes
auront une ville d’origine et l’on pourra reconstituer le chemin le plus
court.
m)
Traduction de l’algorithme
Dans le projet, nous avons donc deux classes Java, une classe Ville et une
classe TheorieGrapheBuilder.
Cette classe contient les objets et méthodes des librairies java qui
permettent l’exécution du programme, elle contient également trois
méthodes personnelles :
afficherChemin(Ville ville){} : qui permet de passer en rouge les villes
par lesquelles l’algorithme est passé pour calculer le chemin le plus
court.
setVilleClic(Ville ville){} : qui contrôle les actions de l’utilisateur du
programme et en particulier le contraint à choisir une ville d’arrivée
et une ville de destination.
calcChemin(Ville ville){} : qui contient notre algorithme qui va calculer
le chemin le plus court. Cette méthode est dite récursive, dans le
code de cette méthode un appel à cette méthode est effectué.
Description :
publicvoidcalcChemin(Ville ville) {
/* si deux villes on été selectionnées */
if (nbBoutonClic == 2) {
/* si la ville traitée n'est pas la ville d'arrivée */
if (!ville.equals(villeArrivee)) {
/*on parcours les villes de destination de la ville passée en paramètre celles ci sont associées à une
valeur ; la distance entre ces deux villes. */
for (Map.Entry<Ville, Integer> villeDest : ville.villesDest.entrySet()) {
/ * si le poids de la ville de destination moins le poids de la ville traitée est supérieur à la valeur de la
distance entre ces deux villes, on affecte à la ville de destination le poids de la ville traitée additionnée
de la valeur decette distance. */
if (villeDest.getKey().poids - ville.poids > villeDest.getValue()) {
villeDest.getKey().poids = villeDest.getValue() + ville.poids;
/*On attribut à la ville de destination comme ville d'origine, la ville passéeen paramètre */
villeDest.getKey().setVilleOrigine(ville);
/*Pour chaque ville de destination (celles ci possèdent aussi des villes dedestination) on effectue la
même opération. */
calcChemin(villeDest.getKey());
}
}
}
/* si deux villes n'ont pas été sélectionnées on affiche un message d'erreur */
} else {
txtErreur.setVisible(true);
}
}
V. Interface Graphique
n)
Description et utilisation de
l’application
Pour cette application, nous avons utilisé une carte de la France, vous
pouvez différentes villes sur la carte représentées par des boutons. Pour
l’utiliser, il vous suffit de cliquer unepremière fois sur le bouton pour choisir
la ville de départ et une deuxième fois pour choisir la ville d’arrivée. Ensuite
cliquer sur le bouton calculer pour calculer pour exécuter le programme.
Ainsi dans le champ distance vous pouvez voir le nombre de kilomètre et
sur la carte le chemin emprunté. Toutefois si vous cliquez par hasard sur
une troisième ville, elle sera définie comme ville de départ et vous serez
donc obliger de redéfinir la ville d’arrivée.
o)
Conclusion
L’algorithme de b
Possibilités d’amélioration :
- Des villes étapes, en effet sur cette application nous ne pouvons pas
définir des villes par lesquels nous voulons absolument passées, nous
somme restreint à choisir une ville de départ et une d’arrivée.
- Un calcul du temps, pouvoir savoir le temps de route entre deux villes
par exemple.
