Rédaction finale.

compte_rendu/compte_rendu.aux

@@ -7,37 +7,71 @@
 \@writefile{toc}{\select@language{french}}
 \@writefile{lof}{\select@language{french}}
 \@writefile{lot}{\select@language{french}}
-\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Diff\IeC {\'e}rentes positions possible de points par rapport \IeC {\`a} $A$ et $B$\relax }}{3}}
+\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Diff\IeC {\'e}rentes positions possible de points par rapport \IeC {\`a} $A$ et $B$\relax }}{2}}
 \providecommand*\caption@xref[2]{\@setref\relax\@undefined{#1}}
-\newlabel{fig:positionsC}{{1}{3}}
+\newlabel{fig:positionsC}{{1}{2}}
-\@writefile{toc}{\contentsline {part}{I\hspace  {1em}Objectifs de ce TL}{3}}
+\@writefile{toc}{\contentsline {part}{I\hspace  {1em}G\IeC {\'e}n\IeC {\'e}ration de carte routi\IeC {\`e}re r\IeC {\'e}aliste}{2}}
-\@writefile{toc}{\contentsline {part}{II\hspace  {1em}G\IeC {\'e}n\IeC {\'e}ration de carte routi\IeC {\`e}re r\IeC {\'e}aliste}{3}}
+\@writefile{toc}{\contentsline {section}{\numberline {1}Condition pour un graphe de Gabriel}{2}}
-\@writefile{toc}{\contentsline {section}{\numberline {1}Condition pour un graphe de Gabriel}{3}}
+\newlabel{eq:condArete}{{1}{2}}
-\newlabel{eq:condArete}{{1}{3}}
+\@writefile{toc}{\contentsline {paragraph}{preuve :}{2}}
-\@writefile{toc}{\contentsline {paragraph}{preuve :}{3}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Mise en pratique : graphe de Gabriel et de voisinage relatif}{2}}
-\@writefile{toc}{\contentsline {section}{\numberline {2}Mise en pratique : graphe de Gabriel et de voisinage relatif}{3}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Cr\IeC {\'e}ation de graphe de Gabriel et de voisinage relatif}{2}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Cr\IeC {\'e}ation de graphe de Gabriel et de voisinage relatif}{3}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}G\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{2}}
-\@writefile{lof}{\contentsline {figure}{\numberline {2}{\ignorespaces Graphe de gabriel\relax }}{4}}
+\@writefile{lof}{\contentsline {figure}{\numberline {2}{\ignorespaces Graphe de gabriel\relax }}{3}}
-\newlabel{fig:2_4_gabriel}{{2}{4}}
+\newlabel{fig:2_4_gabriel}{{2}{3}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3}{\ignorespaces Graphe de voisinage realtif\relax }}{5}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3}{\ignorespaces Graphe de voisinage realtif\relax }}{4}}
-\newlabel{fig:2_4_gvr}{{3}{5}}
+\newlabel{fig:2_4_gvr}{{3}{4}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4}{\ignorespaces R\IeC {\'e}seau g\IeC {\'e}n\IeC {\'e}r\IeC {\'e}\relax }}{6}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4}{\ignorespaces R\IeC {\'e}seau g\IeC {\'e}n\IeC {\'e}r\IeC {\'e}\relax }}{5}}
-\newlabel{fig:2_5}{{4}{6}}
+\newlabel{fig:2_5}{{4}{5}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}G\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{6}}
+\@writefile{lof}{\contentsline {figure}{\numberline {5}{\ignorespaces Temps d'ex\IeC {\'e}cution du r\IeC {\'e}seau na\IeC {\"\i }f\relax }}{6}}
+\newlabel{fig:reseaunaiflog}{{5}{6}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Temps de g\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{6}}
 \@writefile{toc}{\contentsline {section}{\numberline {3}Triangulation de Delaunay}{6}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.1}Pratique}{6}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.2}Aspect th\IeC {\'e}orique}{6}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.1}Condition pour un graphe de Delaunay}{6}}
 \@writefile{toc}{\contentsline {paragraph}{preuve:}{6}}
-\@writefile{lof}{\contentsline {figure}{\numberline {5}{\ignorespaces Cas o\IeC {\`u} le graphe de Delaunay n'est pas planaire.\relax }}{7}}
+\@writefile{lof}{\contentsline {figure}{\numberline {6}{\ignorespaces Cas o\IeC {\`u} le graphe de Delaunay n'est pas planaire.\relax }}{7}}
-\newlabel{fig:delaunayPasPlanaire}{{5}{7}}
+\newlabel{fig:delaunayPasPlanaire}{{6}{7}}
+\@writefile{lof}{\contentsline {figure}{\numberline {7}{\ignorespaces Maille polygonale.\relax }}{7}}
+\newlabel{fig:maillePolygonale}{{7}{7}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.2}Le graphe de Delaunay est planaire}{7}}
 \@writefile{toc}{\contentsline {paragraph}{preuve}{7}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.3}Le graphe de Delaunay est une triangulation}{7}}
 \@writefile{toc}{\contentsline {paragraph}{preuve}{7}}
-\@writefile{lof}{\contentsline {figure}{\numberline {6}{\ignorespaces Maille polygonale.\relax }}{8}}
-\newlabel{fig:maillePolygonale}{{6}{8}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.4}Condition sur les faces}{8}}
 \@writefile{toc}{\contentsline {paragraph}{preuve}{8}}
-\@writefile{toc}{\contentsline {part}{III\hspace  {1em}Algorithme de Dijkstra pour la recherche du plus court chemin}{8}}
+\@writefile{lof}{\contentsline {figure}{\numberline {8}{\ignorespaces Algorithme de Dijkstra avec des co\IeC {\^u}ts constants\relax }}{9}}
+\newlabel{fig:31}{{8}{9}}
+\@writefile{toc}{\contentsline {part}{II\hspace  {1em}Algorithme de Dijkstra pour la recherche du plus court chemin}{9}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}Algorithme de Dijkstra}{9}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}Co\IeC {\^u}ts constants}{9}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Co\IeC {\^u}ts variables}{9}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3}Temps de calcul}{9}}
+\@writefile{toc}{\contentsline {section}{\numberline {5}Dijkstra avec tas}{9}}
+\@writefile{toc}{\contentsline {section}{\numberline {6}Algorithme A*}{9}}
+\@writefile{lof}{\contentsline {figure}{\numberline {9}{\ignorespaces Dijkstra avec le carburant comme co\IeC {\^u}t\relax }}{10}}
+\newlabel{fig:32carburant}{{9}{10}}
+\@writefile{lof}{\contentsline {figure}{\numberline {10}{\ignorespaces Dijkstra avec le temps comme co\IeC {\^u}t\relax }}{10}}
+\newlabel{fig:32temps}{{10}{10}}
+\@writefile{lof}{\contentsline {figure}{\numberline {11}{\ignorespaces Temps d'ex\IeC {\'e}cution de l'algorithme de Dijkstra\relax }}{10}}
+\newlabel{fig:33}{{11}{10}}
+\@writefile{lof}{\contentsline {figure}{\numberline {12}{\ignorespaces Comparaison des temps d'ex\IeC {\'e}cution de Dijkstra et Dijkstra avec tas\relax }}{11}}
+\newlabel{fig:36}{{12}{11}}
+\@writefile{lof}{\contentsline {figure}{\numberline {13}{\ignorespaces Comparaison des trois algorithmes (temps moyens sur 10 ex\IeC {\'e}cutions)\relax }}{12}}
+\newlabel{fig:39}{{13}{12}}
+\@writefile{lof}{\contentsline {figure}{\numberline {14}{\ignorespaces Tourn\IeC {\'e}e optimale obtenue par backtracking\relax }}{13}}
+\newlabel{fig:42}{{14}{13}}
+\@writefile{toc}{\contentsline {part}{III\hspace  {1em}Probl\IeC {\`e}me du voyageur de commerce}{13}}
+\@writefile{toc}{\contentsline {section}{\numberline {7}R\IeC {\'e}solution par Backtracking}{13}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.1}R\IeC {\'e}solution}{13}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.2}Temps d'ex\IeC {\'e}cution}{13}}
+\@writefile{toc}{\contentsline {section}{\numberline {8}R\IeC {\'e}solution approch\IeC {\'e}e}{13}}
+\@writefile{lof}{\contentsline {figure}{\numberline {15}{\ignorespaces Temps d'ex\IeC {\'e}cution de l'algorithme par backtracking\relax }}{14}}
+\newlabel{fig:43}{{15}{14}}
+\@writefile{lof}{\contentsline {figure}{\numberline {16}{\ignorespaces Voyageur de commerce approch\IeC {\'e}\relax }}{14}}
+\newlabel{fig:48approx}{{16}{14}}
+\@writefile{lof}{\contentsline {figure}{\numberline {17}{\ignorespaces Voyageur de commerce na\IeC {\"\i }f\relax }}{14}}
+\newlabel{fig:48naif}{{17}{14}}
+\@writefile{lof}{\contentsline {figure}{\numberline {18}{\ignorespaces Temps d'ex\IeC {\'e}cution de la r\IeC {\'e}solution approch\IeC {\'e}e\relax }}{15}}
+\newlabel{fig:49}{{18}{15}}

compte_rendu/compte_rendu.lof

@@ -1,7 +1,19 @@
 \select@language {french}
-\contentsline {figure}{\numberline {1}{\ignorespaces Diff\IeC {\'e}rentes positions possible de points par rapport \IeC {\`a} $A$ et $B$\relax }}{3}
+\contentsline {figure}{\numberline {1}{\ignorespaces Diff\IeC {\'e}rentes positions possible de points par rapport \IeC {\`a} $A$ et $B$\relax }}{2}
-\contentsline {figure}{\numberline {2}{\ignorespaces Graphe de gabriel\relax }}{4}
+\contentsline {figure}{\numberline {2}{\ignorespaces Graphe de gabriel\relax }}{3}
-\contentsline {figure}{\numberline {3}{\ignorespaces Graphe de voisinage realtif\relax }}{5}
+\contentsline {figure}{\numberline {3}{\ignorespaces Graphe de voisinage realtif\relax }}{4}
-\contentsline {figure}{\numberline {4}{\ignorespaces R\IeC {\'e}seau g\IeC {\'e}n\IeC {\'e}r\IeC {\'e}\relax }}{6}
+\contentsline {figure}{\numberline {4}{\ignorespaces R\IeC {\'e}seau g\IeC {\'e}n\IeC {\'e}r\IeC {\'e}\relax }}{5}
-\contentsline {figure}{\numberline {5}{\ignorespaces Cas o\IeC {\`u} le graphe de Delaunay n'est pas planaire.\relax }}{7}
+\contentsline {figure}{\numberline {5}{\ignorespaces Temps d'ex\IeC {\'e}cution du r\IeC {\'e}seau na\IeC {\"\i }f\relax }}{6}
-\contentsline {figure}{\numberline {6}{\ignorespaces Maille polygonale.\relax }}{8}
+\contentsline {figure}{\numberline {6}{\ignorespaces Cas o\IeC {\`u} le graphe de Delaunay n'est pas planaire.\relax }}{7}
+\contentsline {figure}{\numberline {7}{\ignorespaces Maille polygonale.\relax }}{7}
+\contentsline {figure}{\numberline {8}{\ignorespaces Algorithme de Dijkstra avec des co\IeC {\^u}ts constants\relax }}{9}
+\contentsline {figure}{\numberline {9}{\ignorespaces Dijkstra avec le carburant comme co\IeC {\^u}t\relax }}{10}
+\contentsline {figure}{\numberline {10}{\ignorespaces Dijkstra avec le temps comme co\IeC {\^u}t\relax }}{10}
+\contentsline {figure}{\numberline {11}{\ignorespaces Temps d'ex\IeC {\'e}cution de l'algorithme de Dijkstra\relax }}{10}
+\contentsline {figure}{\numberline {12}{\ignorespaces Comparaison des temps d'ex\IeC {\'e}cution de Dijkstra et Dijkstra avec tas\relax }}{11}
+\contentsline {figure}{\numberline {13}{\ignorespaces Comparaison des trois algorithmes (temps moyens sur 10 ex\IeC {\'e}cutions)\relax }}{12}
+\contentsline {figure}{\numberline {14}{\ignorespaces Tourn\IeC {\'e}e optimale obtenue par backtracking\relax }}{13}
+\contentsline {figure}{\numberline {15}{\ignorespaces Temps d'ex\IeC {\'e}cution de l'algorithme par backtracking\relax }}{14}
+\contentsline {figure}{\numberline {16}{\ignorespaces Voyageur de commerce approch\IeC {\'e}\relax }}{14}
+\contentsline {figure}{\numberline {17}{\ignorespaces Voyageur de commerce na\IeC {\"\i }f\relax }}{14}
+\contentsline {figure}{\numberline {18}{\ignorespaces Temps d'ex\IeC {\'e}cution de la r\IeC {\'e}solution approch\IeC {\'e}e\relax }}{15}

compte_rendu/compte_rendu.tex

@@ -16,11 +16,8 @@
 \maketitle
 \tableofcontents
 \clearpage
-\listoffigures
-\newpage
 \initPage{TL - ASD}{\today}{\bsc{Simon}, \bsc{Levy--Falk}}
 
-\part{Objectifs de ce TL}
 \part{Génération de carte routière réaliste}
 
 \section{Condition pour un graphe de Gabriel}
@@ -91,16 +88,14 @@ En combinant la génération de graphe de Gabriel et de voisinage relatif, on pe
 \end{figure}
 
 \subsection{Temps de génération d'un réseau}
-La figure \ref{fig:reseaunaiflog} montre le temps nécessaire à la création d'un réseau. 
+La figure \ref{fig:reseaunaiflog} montre le temps nécessaire à la création d'un réseau. On remarque que la complexité est en $\Theta(n^3)$.
 \begin{figure}
 	\centering
 	\includegraphics[width=0.7\linewidth]{images/reseau_naif_log}
-	\caption{}
+	\caption{Temps d'exécution du réseau naïf}
 	\label{fig:reseaunaiflog}
 \end{figure}
 
-
-
 \section{Triangulation de Delaunay}
 \subsection{Pratique}
 \subsection{Aspect théorique}
@@ -196,9 +191,119 @@ Donc l'arête $\{A,B\}$ existe. On montre de la même façon que  $\{A,C\}$ et $
 
 Supposons que $\{A,B,C\}$ soit une face de la triangulation. En particulier, $C$ est alors le point de plus grand angle $\widehat{ACB} = \theta$ sur $\mathcal{P}$. Puisque $\{A,B\}$ est une arête, d'après le lemme, tout point $D\in\mathcal{P}'\cap\mathcal{V}$ est d'angle $\widehat{ADB}$ plus petit que $\pi - \theta$. Donc un tel point $D$ ne peut être dans le disque délimité par $(\mathcal{L}(\theta, A, B) \cap \mathcal{P}) \cup (\mathcal{L}(\pi - \theta, A, B)\cap \mathcal{P}')$. $\square$
 
-
+\clearpage
 \part{Algorithme de Dijkstra pour la recherche du plus court chemin}
 
+\section{Algorithme de Dijkstra}
+\subsection{Coûts constants}
+Après avoir implémenté l'algorithme de Dijkstra, on le teste avec des coûts constants (figure \ref{fig:31}).
 
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/3_1}
+	\caption{Algorithme de Dijkstra avec des coûts constants}
+	\label{fig:31}
+\end{figure}
+
+\subsection{Coûts variables}
+On implémente la variation du coût de la manière suivante : on stocke le mode de calcul des coûts dans la classe \verb|Graphe| et les objets de type \verb|Arete| vienne le lire pour donner leur coût avec la méthode décorée \verb|cout|. Le résultat est montré par les figures \ref{fig:32carburant} et \ref{fig:32temps}.
+
+\begin{figure}
+	\centering
+	\begin{minipage}{0.45\textwidth}
+		\centering
+		\includegraphics[width=\textwidth]{images/3_2_carburant}
+		\caption{Dijkstra avec le carburant comme coût}
+		\label{fig:32carburant}
+	\end{minipage}
+\begin{minipage}{0.45\textwidth}
+	\centering
+\includegraphics[width=\textwidth]{images/3_2_temps}
+\caption{Dijkstra avec le temps comme coût}
+\label{fig:32temps}
+\end{minipage}
+\end{figure}
+
+\subsection{Temps de calcul}
+On mesure le temps d'exécution de l'algorithme (figure \ref{fig:33}).
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/3_3}
+	\caption{Temps d'exécution de l'algorithme de Dijkstra}
+	\label{fig:33}
+\end{figure}
+
+\section{Dijkstra avec tas}
+On implémente Dijkstra avec un tas et on compare les temps d'exécutions (figure \ref{fig:36}). On remarque qu'ici le temps d'exécution de Dijkstra avec tas est supérieur. Cela peut être dû à l'implémentation. En effet Dijkstra sans tas utilise des fonctions \verb|builtin| qui sont donc plus rapide. Étant donné que les temps d'exécutions, on peut penser que $m\in\Theta(n)$.
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/3_6}
+	\caption{Comparaison des temps d'exécution de Dijkstra et Dijkstra avec tas}
+	\label{fig:36}
+\end{figure}
+\section{Algorithme A*}
+On implémente l'algorithme A* et on vérifie qu'il donne le même résultat que Dijkstra en visitant moins de sommets.
+
+On compare ensuite les temps d'exécutions des 3 algorithmes (figure \ref{fig:39}). On remarque que A* est le plus efficace quand le nombre de points augmente.
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/3_9}
+	\caption{Comparaison des trois algorithmes (temps moyens sur 10 exécutions)}
+	\label{fig:39}
+\end{figure}
+
+\clearpage
+\part{Problème du voyageur de commerce}
+\section{Résolution par Backtracking}
+\subsection{Résolution}
+On résout le problème du voyageur de commerce par backtracking. Un état correspond à un parcours partiel de la tournée (représenté par une liste d'indice des sommets de la tournée). L'ensemble des extensions possibles d'un état correspond à l'ajout d'un sommet non encore visité. On élague si le cout minimum est inférieur au cout actuel auquel on ajoute le cout de l'ajout d'un sommet.
+
+On obtient le résultat de la figure \ref{fig:42}.
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/4_2}
+	\caption{Tournée optimale obtenue par backtracking}
+	\label{fig:42}
+\end{figure}
+
+\subsection{Temps d'exécution}
+En mesurant le temps d'exécution de l'algorithme, on note son caractère exponentiel (figure \ref{fig:43}), ce qui le rend inutilisable en pratique.
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/4_3}
+	\caption{Temps d'exécution de l'algorithme par backtracking}
+	\label{fig:43}
+\end{figure}
+
+\section{Résolution approchée}
+On résout le problème de manière approchée en construisant un graphe de coût. Ce graphe est complet. On utilise alors l'algorithme de Prim pour trouver un arbre couvrant minimal et ainsi en déduire un ordre de parcours des points de la tournée. Les figures \ref{fig:48approx} et \ref{fig:48naif} montrent que les algorithmes peuvent donner des solutions différentes.
+
+\begin{figure}
+	\centering
+	\begin{minipage}{0.45\textwidth}
+		\centering
+		\includegraphics[width=\textwidth]{images/3_2_carburant}
+		\caption{Voyageur de commerce approché}
+		\label{fig:48approx}
+	\end{minipage}
+	\begin{minipage}{0.45\textwidth}
+		\centering
+		\includegraphics[width=\textwidth]{images/3_2_temps}
+		\caption{Voyageur de commerce naïf}
+		\label{fig:48naif}
+	\end{minipage}
+\end{figure}
+
+La figure \ref{fig:49} donne le temps d'exécution de la résolution approchée. On remarque que cette solution semble beaucoup plus rapide que la solution naïve.
+
+\begin{figure}
+	\centering
+	\includegraphics[width=0.7\linewidth]{images/4_9}
+	\caption{Temps d'exécution de la résolution approchée}
+	\label{fig:49}
+\end{figure}
+
+\clearpage
+\listoffigures
 
 \end{document}

compte_rendu/compte_rendu.toc

@@ -1,11 +1,10 @@
 \select@language {french}
-\contentsline {part}{I\hspace {1em}Objectifs de ce TL}{3}
+\contentsline {part}{I\hspace {1em}G\IeC {\'e}n\IeC {\'e}ration de carte routi\IeC {\`e}re r\IeC {\'e}aliste}{2}
-\contentsline {part}{II\hspace {1em}G\IeC {\'e}n\IeC {\'e}ration de carte routi\IeC {\`e}re r\IeC {\'e}aliste}{3}
+\contentsline {section}{\numberline {1}Condition pour un graphe de Gabriel}{2}
-\contentsline {section}{\numberline {1}Condition pour un graphe de Gabriel}{3}
+\contentsline {paragraph}{preuve :}{2}
-\contentsline {paragraph}{preuve :}{3}
+\contentsline {section}{\numberline {2}Mise en pratique : graphe de Gabriel et de voisinage relatif}{2}
-\contentsline {section}{\numberline {2}Mise en pratique : graphe de Gabriel et de voisinage relatif}{3}
+\contentsline {subsection}{\numberline {2.1}Cr\IeC {\'e}ation de graphe de Gabriel et de voisinage relatif}{2}
-\contentsline {subsection}{\numberline {2.1}Cr\IeC {\'e}ation de graphe de Gabriel et de voisinage relatif}{3}
+\contentsline {subsection}{\numberline {2.2}G\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{2}
-\contentsline {subsection}{\numberline {2.2}G\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{6}
 \contentsline {subsection}{\numberline {2.3}Temps de g\IeC {\'e}n\IeC {\'e}ration d'un r\IeC {\'e}seau}{6}
 \contentsline {section}{\numberline {3}Triangulation de Delaunay}{6}
 \contentsline {subsection}{\numberline {3.1}Pratique}{6}
@@ -18,4 +17,15 @@
 \contentsline {paragraph}{preuve}{7}
 \contentsline {subsubsection}{\numberline {3.2.4}Condition sur les faces}{8}
 \contentsline {paragraph}{preuve}{8}
-\contentsline {part}{III\hspace {1em}Algorithme de Dijkstra pour la recherche du plus court chemin}{8}
+\contentsline {part}{II\hspace {1em}Algorithme de Dijkstra pour la recherche du plus court chemin}{9}
+\contentsline {section}{\numberline {4}Algorithme de Dijkstra}{9}
+\contentsline {subsection}{\numberline {4.1}Co\IeC {\^u}ts constants}{9}
+\contentsline {subsection}{\numberline {4.2}Co\IeC {\^u}ts variables}{9}
+\contentsline {subsection}{\numberline {4.3}Temps de calcul}{9}
+\contentsline {section}{\numberline {5}Dijkstra avec tas}{9}
+\contentsline {section}{\numberline {6}Algorithme A*}{9}
+\contentsline {part}{III\hspace {1em}Probl\IeC {\`e}me du voyageur de commerce}{13}
+\contentsline {section}{\numberline {7}R\IeC {\'e}solution par Backtracking}{13}
+\contentsline {subsection}{\numberline {7.1}R\IeC {\'e}solution}{13}
+\contentsline {subsection}{\numberline {7.2}Temps d'ex\IeC {\'e}cution}{13}
+\contentsline {section}{\numberline {8}R\IeC {\'e}solution approch\IeC {\'e}e}{13}

graphe.py

@@ -22,7 +22,7 @@ class Graphe:
         self.nom = nom
         self.sommets = []
         self.aretes = []
-        self.cout = Graphe.Cout.TEMPS
+        self.cout = None
         self.arrivee = None
 
     def renomme(self, nom):
@@ -292,6 +292,7 @@ class Graphe:
         """Calcule la matrice de cout d'une tournée.
 
         :param tournee:La liste des étapes avec en première position le départ.
+        :return: la matrice des couts.
         """
         n = len(tournee)
         matrice = np.zeros((n, n))
@@ -302,6 +303,11 @@ class Graphe:
         return matrice
 
     def voyageurDeCommerceNaif(self, tournee):
+        """Résout le problème du voyageur de commerce par backtracking.
+
+        :param tournee: La liste des sommets à visiter.
+        :return: le cout minimal et l'itinéraire associé.
+        """
         meilleurItineraire = []
         minCout = sys.float_info.max
         matrice = self.matriceCout(tournee)
@@ -323,15 +329,20 @@ class Graphe:
                             visite[i] = True
                             indicePrec = itineraire[-1]
                             itineraire.append(i)
+                            if cout + matrice[i, indicePrec] < minCout:
                                 cout += matrice[i, indicePrec]
                                 backtrack()
-                            visite[i] = False
                                 cout -= matrice[i, indicePrec]
+                            visite[i] = False
                             itineraire.pop()
         backtrack()
         return minCout, meilleurItineraire
 
     def traceItineraire(self, itineraire):
+        """Colorie les arêtes d'un itinéraire.
+
+        :param itineraire: les points de la tournée ordonnés.
+        """
         for i, x in enumerate(itineraire):
             x.nom = "s" + str(i)
             suivant = itineraire[(i + 1) % len(itineraire)]
@@ -339,6 +350,12 @@ class Graphe:
             self.colorieChemin(c, (0.8, 0.1, 0.8))
 
     def Prim(self):
+        """Applique l'algorithme de Prim sur le graphe.
+        Les sommets et arêtes sont ajoutés à l'arbre en passant leur flag
+        selection à True.
+
+        :return: le poids de l'arbre minimal
+        """
         for s in self.sommets:
             s.selection = False
         for a in self.aretes:
@@ -347,7 +364,6 @@ class Graphe:
         for a in self.sommets[0].aretes:
             aretes.ajoute(a)
         self.sommets[0].selection = True
-        arbre = []
         ptot = 0
         while not aretes.empty():
             a = aretes.pop()
@@ -375,6 +391,11 @@ class Graphe:
                 s.couleur = couleur
 
     def grapheDeCout(self, tournee):
+        """Génère le graphe de coût pour la tournée.
+
+        :param tournee: la tournée.
+        :return: le graphe de coûts.
+        """
         g = Graphe("Graphe de cout de " + self.nom)
         for s in tournee:
             s_a = g.ajouteSommet(s.x(), s.y())
@@ -389,6 +410,11 @@ class Graphe:
         return g
 
     def tourneeApproximative(self, tournee):
+        """Résout le problème du voyageur de commerce de manière approximative.
+
+        :param tournee: les sommets à visiter
+        :return: Le chemin optimal approché
+        """
         g_cout = self.grapheDeCout(tournee)
         g_cout.Prim()
         pile = stack.Stack()
@@ -431,6 +457,8 @@ class Sommet:
 
     @property
     def minCumulRestant(self):
+        """Minore le cumul restant pour le sommet considéré.
+        """
         x, y = self.graphe.arrivee.pos
         d = ((self.pos[0] - x)**2 + (self.pos[1] - y)**2)**(1 / 2)
         if self.graphe.cout is Graphe.Cout.TEMPS:
@@ -466,8 +494,7 @@ class Sommet:
 class Arete:
     """Implémente une arête de graphe."""
 
-    def __init__(
+    def __init__(self, **kwargs):
-            self, s1, s2, longueur, v_moyenne, graph, couleur=(0., 0., 0.)):
         """Initialise une arête.
 
         :param s1: sommet 1.
@@ -477,14 +504,14 @@ class Arete:
         :param couleur: couleur de l'arête.
         :param graph: le graphe de l'arête.
         """
-        self.s1 = s1
+        self.s1 = kwargs.get('s1')
-        self.s2 = s2
+        self.s2 = kwargs.get('s2')
-        s1.aretes.add(self)
+        self.s1.aretes.add(self)
-        s2.aretes.add(self)
+        self.s2.aretes.add(self)
-        self.longueur = longueur
+        self.longueur = kwargs.get('longueur')
-        self.v_moyenne = v_moyenne
+        self.v_moyenne = kwargs.get('v_moyenne')
-        self.couleur = couleur
+        self.couleur = kwargs.get('couleur', (0., 0., 0.))
-        self.graph = graph
+        self.graph = kwargs.get('graph')
         self.selection = False
 
     def voisin(self, s):

test.py

@@ -15,6 +15,7 @@ import numpy as np
 import matplotlib.pyplot as pl
 import time
 
+
 def creerGrapheFigure1():
     """ Crée le graphe de la figure 1 """
     g = graphe.Graphe("Graphe de la figure 1")
@@ -86,22 +87,25 @@ def chronometre(fonctionTest, fonctionPreparation, parametres):
     temps = []
     # Pour chaque valeur de paramètre
     for p in parametres:
-        # Génère les entrées du test pour la valeur p
-        entrees = fonctionPreparation(p)
         # Lance le test pour ces entrées
         print("t({}) = ".format(p), end="", flush=True)
+        t = []
+        for i in range(10):
+            entrees = fonctionPreparation(p)
             debut = time.time()
             fonctionTest(entrees)
             fin = time.time()
             # Mesure le temps d ' exécution
-        t = (fin - debut)
+            t.append(fin - debut)
+        t = sum(t)/10
         print("{:.2f} s".format(t))
         temps.append(t)
     return temps
 
+
 def testQuestion2_6():
     """Mesure la performance de graphe.reseau"""
-    prepare = lambda p : graphe.pointsAleatoires(p, 10)
+    def prepare(p): return graphe.pointsAleatoires(p, 10)
     valeurs_n = list(map(int, np.logspace(1, 2.7, 100)))
     temps = chronometre(graphe.reseau, prepare, valeurs_n)
     pl.close('all')
@@ -112,15 +116,16 @@ def testQuestion2_6():
     pl.show()
     pl.title("Mesure du temps d'exécution de `reseau`.")
     pl.loglog(valeurs_n, temps, label='temps de calcul')
-    pl.loglog(valeurs_n, (lambda x : x**3)(valeurs_n), label='$x\mapsto x^3$')
+    pl.loglog(valeurs_n, (lambda x: x**3)(valeurs_n), label='$x\mapsto x^3$')
     pl.legend(loc='best')
     pl.xlabel("n")
     pl.ylabel("temps")
     pl.show()
 
+
 def testQuestion2_7():
     """Compare la création de graphe de gabriel et ed delaunay."""
-    prepare = lambda p : graphe.pointsAleatoires(p, 10)
+    def prepare(p): return graphe.pointsAleatoires(p, 10)
     valeurs_n = np.arange(1, 200)
     temps1 = chronometre(graphe.gabriel, prepare, valeurs_n)
     temps2 = chronometre(graphe.delaunay, prepare, valeurs_n)
@@ -133,6 +138,7 @@ def testQuestion2_7():
     pl.ylabel('temps')
     pl.show()
 
+
 def testQuestion2_8():
     """Compare le reseau naif et non naif."""
     g = graphe.pointsAleatoires(30, 30)
@@ -145,9 +151,10 @@ def testQuestion2_8():
     graphique.affiche(g, (0, 0), 10.)
     graphique.affiche(g1, (0, 0), 10.)
 
+
 def testQuestion2_9():
     """Compare le temps de création des deux méthodes de création de réseau"""
-    prepare = lambda p : graphe.pointsAleatoires(p, 10)
+    def prepare(p): return graphe.pointsAleatoires(p, 10)
     valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 30)))
     temps1 = chronometre(graphe.reseau, prepare, valeurs_n)
     temps2 = chronometre(graphe.reseauRapide, prepare, valeurs_n)
@@ -199,19 +206,24 @@ def testQuestion3_2():
 
 def testQuestion3_3():
     """Mesure le temps d'exécution de Dijkstra."""
-    prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 100))
+    def prepare(p): return graphe.reseauRapide(graphe.pointsAleatoires(p, 100))
-    valeurs_n = list(map(lambda x: int(x), np.logspace(1, 4, 10)))
+    valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 100)))
     temps = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
+
+    def f(x): return x*np.log(x)
+    theorie = [f(x) for x in valeurs_n]
     pl.close('all')
     pl.title("Temps d'exécution en fonction de la taille du graphe.")
-    pl.plot(valeurs_n, temps, label='reseau')
+    pl.plot(valeurs_n, temps, label="Dijkstra")
-    pl.legend(loc='best')
+    pl.plot(valeurs_n, theorie, label="$x \mapsto x\log x$")
+    pl.legend(loc="best")
     pl.xlabel("n")
     pl.ylabel("temps")
     pl.show()
     pl.title("Temps d'exécution en fonction de la taille du graphe.")
-    pl.loglog(valeurs_n, temps, label='reseau')
+    pl.loglog(valeurs_n, temps)
-    pl.legend(loc='best')
+    pl.loglog(valeurs_n, theorie, label="$x \mapsto x\log x$")
+    pl.legend(loc="best")
     pl.xlabel("n")
     pl.ylabel("temps")
     pl.show()
@@ -226,7 +238,7 @@ def testQuestion3_4():
     g.fixeTempsCommeCout()
     g.dijkstra(g.sommets[0])
     c = g.cheminOptimal(g.sommets[-1])
-    g.colorieChemin(c, (0.,1.,0.))
+    g.colorieChemin(c, (0., 1., 0.))
     g.renomme("Temps")
     graphique.affiche(g, (0, 0), 10.)
 
@@ -249,7 +261,7 @@ def testQuestion3_5():
 
 def testQuestion3_6():
     """Compare Dijkstra avec et sans tas."""
-    prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
+    def prepare(p): return graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
     valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 10)))
     temps1 = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
     temps2 = chronometre(graphe.Graphe.dijkstraAvecTas, prepare, valeurs_n)
@@ -300,13 +312,14 @@ def testQuestion3_8():
 
 def testQuestion3_9():
     """Compare Dijkstra avec et sans tas et A*."""
-    prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
+    def prepare(p): return graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
-    valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 50)))
+    valeurs_n = list(map(lambda x: int(x), np.logspace(1, 2.5, 30)))
     temps1 = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
     temps2 = chronometre(graphe.Graphe.dijkstraPartiel, prepare, valeurs_n)
     temps3 = chronometre(graphe.Graphe.astar, prepare, valeurs_n)
     pl.close('all')
-    pl.title("Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
+    pl.title(
+        "Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
     pl.plot(valeurs_n, temps1, label='Dijkstra')
     pl.plot(valeurs_n, temps2, label='Dijkstra partiel avec tas')
     pl.plot(valeurs_n, temps3, label='A*')
@@ -314,7 +327,8 @@ def testQuestion3_9():
     pl.xlabel("n")
     pl.ylabel("temps")
     pl.show()
-    pl.title("Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
+    pl.title(
+        "Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
     pl.loglog(valeurs_n, temps1, label='Dijkstra')
     pl.loglog(valeurs_n, temps2, label='Dijkstra partiel avec tas')
     pl.loglog(valeurs_n, temps3, label='A*')
@@ -343,7 +357,7 @@ def testQuestion4_2():
     g.renomme("graphe")
     print("Points 0,1,2 et 7")
     tournee = [g.sommets[i] for i in (0, 1, 2, 7)]
-    cout,iti = g.voyageurDeCommerceNaif(tournee)
+    cout, iti = g.voyageurDeCommerceNaif(tournee)
     g.traceItineraire(iti)
     graphique.affiche(g, (0, 0), 10.)
 
@@ -351,8 +365,9 @@ def testQuestion4_2():
 def testQuestion4_3():
     """Mesure le temps de calcul."""
     g = graphe.reseauRapide(graphe.pointsAleatoires(1000, 1000))
-    prepare = lambda p : random.sample(g.sommets, p)
+
-    valeurs_n = list(map(int, np.linspace(1, 15, 10)))
+    def prepare(p): return random.sample(g.sommets, p)
+    valeurs_n = list(map(int, np.linspace(1, 11, 10)))
     temps = chronometre(g.voyageurDeCommerceNaif, prepare, valeurs_n)
     pl.close('all')
     pl.title("Temps d'exécution pour le voyageur de commerce.")
@@ -396,14 +411,15 @@ def testQuestion4_8():
 
     graphe.reseauRapide(g)
     g.fixeTempsCommeCout()
-    g.renomme("Graphe de test (cout=temps)")
+    g.renomme("Graphe de test (cout=temps) tournée approximative")
     g1 = copy.deepcopy(g)
+    g1.renomme("Graphe de test (cout=temps) tournée naïve")
     print("Tournée 0, 1, 2, 7")
     tournee = [g.sommets[i] for i in (0, 1, 2, 7)]
     iti = g.tourneeApproximative(tournee)
     g.traceItineraire(iti)
     tournee = [g1.sommets[i] for i in (0, 1, 2, 7)]
-    cout,iti = g1.voyageurDeCommerceNaif(tournee)
+    cout, iti = g1.voyageurDeCommerceNaif(tournee)
     g1.traceItineraire(iti)
     graphique.affiche(g, (0, 0), 10., blocage=False)
     graphique.affiche(g1, (0, 0), 10.)
@@ -412,8 +428,9 @@ def testQuestion4_8():
 def testQuestion4_9():
     """Mesure le temps de calcul."""
     g = graphe.reseauRapide(graphe.pointsAleatoires(1000, 1000))
-    prepare = lambda p : random.sample(g.sommets, p)
+
-    valeurs_n = list(map(int, np.logspace(1, 2, 30)))
+    def prepare(p): return random.sample(g.sommets, p)
+    valeurs_n = list(map(int, np.logspace(1, 3, 30)))
     temps = chronometre(g.tourneeApproximative, prepare, valeurs_n)
     pl.close('all')
     pl.title("Temps d'exécution pour le voyageur de commerce approximatif.")
@@ -427,6 +444,7 @@ def testQuestion4_9():
     pl.ylabel("temps")
     pl.show()
 
+
 if __name__ == '__main__':
     n = sys.argv[1]
     if n in ('--help', '-h'):