From 97335d9538071bc64065d96b66833e6597a2c10b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Pelletier?= Date: Mon, 23 Apr 2018 01:08:52 -0400 Subject: [PATCH] ajout chapitre 6 et section chapitre 7 --- bibliographie.bib | 10 ++ chapitre2.tex | 5 - chapitre6.tex | 74 +++++++++++++ chapitre7.tex | 218 +++++++++++++++++++++++++++++++++++++- exemple_flot.dot | 10 ++ exemple_flot_residuel.dot | 5 + makefile | 10 +- 7 files changed, 325 insertions(+), 7 deletions(-) create mode 100644 exemple_flot.dot create mode 100644 exemple_flot_residuel.dot diff --git a/bibliographie.bib b/bibliographie.bib index e69de29..2efd752 100644 --- a/bibliographie.bib +++ b/bibliographie.bib @@ -0,0 +1,10 @@ +@book{papadimitriou2013combinatorial, + title={Combinatorial Optimization: Algorithms and Complexity}, + author={Papadimitriou, C.H. and Steiglitz, K.}, + isbn={9780486320137}, + series={Dover Books on Computer Science}, + url={https://books.google.com/books?id=BSPCAgAAQBAJ}, + year={2013}, + publisher={Dover Publications} +} + diff --git a/chapitre2.tex b/chapitre2.tex index a08dc83..3791a2c 100644 --- a/chapitre2.tex +++ b/chapitre2.tex @@ -208,11 +208,6 @@ On vérifie si pour chaque arête, il existe une chemin de longueur $l$ reliant On applique généralement la cohérence de chemin de longueur 2 qui est équivalente et a $\binom{n}{3}$ permutations. La complexité est $\mathcal{O}(n^3)$. - - - - - %%% Local Variables: %%% mode: latex %%% TeX-master: "notes_de_cours" diff --git a/chapitre6.tex b/chapitre6.tex index fb66dc6..d0bcba4 100644 --- a/chapitre6.tex +++ b/chapitre6.tex @@ -28,8 +28,82 @@ Techniques additionnelles \subsection{Heuristiques de choix de valeurs} \label{sec:choixvaleurs} +\begin{itemize} +\item Le choix dépend souvent d'une connaissance du problème. On peut trier les valeurs du premier choix au dernier choix. +\item Déviation: solveur branche sur une valeur qui n'est pas le premier choix +\end{itemize} +\subsection{Fouille LDS} +\label{sec:fouillelds} +\begin{algorithm}[H] + \DontPrintSemicolon + \Deb{ + $Candidats \leftarrow \lbrace X_i \mid |dom(X_i)| >1 \rbrace$ \; + \Si{$Candidats = \emptyset$}{ + \Si{$dom(X_1),\ldots,dom(X_n)$ sat. contraintes}{ + \Retour{$dom(X_1),\ldots,dom(X_n)$} + } + \Sinon{ + \Retour{$\emptyset$} + } + } + Choisir une variable $X_i \in Candidats$ \; + \Si{$nbDeviations < |Candidats|$}{ + $Solution \leftarrow LDS(dom(X_1),\ldots,dom(X_{i-1}),\lbrace v_1 \rbrace, \ldots, dom(X_n)4,nbDeviations)$ \; + \Si{$Solution \neq \emptyset$}{\Retour{$Solution$}} + } + \Si{$nbDeviations>0$}{ + $Solution \leftarrow LDS(dom(X_1),\ldots,dom(X_{i-1}),\lbrace v_2 \rbrace, \ldots, dom(X_n),nbDeviations)$ \; + \Si{$Solution \neq \emptyset$}{\Retour{$Solution$}} + } + \Retour{$\emptyset$} \; + } + \caption{LDS($dom(X_1),\ldots,dom(X_n)$,nbDeviations)} +\end{algorithm} + +\subsection{Redémarrage} +\label{sec:redemarrage} + +\begin{itemize} +\item Heuristique stochastique: après un certain temps ou un certain nombre de retours arrières, on redémarre la recherche +\item Possibilité de visiter deux fois le même noeud: risque à prendre, inefficace, mais acceptable +\item Si on ne fait pas attention: possibilité de ne jamais visiter une branche de l'arbre, inacceptable +\end{itemize} + +Stratégies de redémarrage: + +Garantissent que la totalité de l'arbre est visité +\begin{itemize} +\item Géométrique: $1, r, r^2, r^3, ... | r>1$ +\item Luby: $1,1,2,1,1,2,4,1,1,2,1,1,2,4,8, \ldots$ nombre de retours arrières est à un facteur logarithmique de la séquence optimale +\end{itemize} + +\subsection{Nogoods} +\label{sec:nogoods} + +\begin{itemize} +\item Cette stratégie réduit la possibilité de revisiter des noeuds +\item Contrainte ajoutée au modèle, prévient un second retour arrière pour les mêmes raisons +\item Un noeud est identifié par un ensemble de contraintes de branchement $p(n)= \lbrace b1, \ldots, b_j\rbrace$ +\item Soit $n$ le noeud où le retour arrière est déclenché sans avoir visité ses descendants. Au moins une contrainte a été violée. + \begin{align} + J(n) = \lbrace b_i \in p(n) \mid portée(bi) \cap portée(C) \neq \emptyset \rbrace + \end{align} +\item Si un retour arrière se produit sur chacun des enfants $c_1, \ldots, c_k$ de $n$ + \begin{align} + J(n) = p(n) \bigcup_{i=1}^k J(c_i) + \end{align} +\item Favoriser l'arité du nogood la plus petite +\item Gestion: Effacer ... + \begin{itemize} + \item les plus vieux, + \item les moins appelés, + \item ceux avec arité la plus grande + \end{itemize} +\end{itemize} + +Les solveurs SAT utilisent des heuristiques d'apprentissage, le redémarrage et des nogoods diff --git a/chapitre7.tex b/chapitre7.tex index aa52637..9999daf 100644 --- a/chapitre7.tex +++ b/chapitre7.tex @@ -1,7 +1,223 @@ -\section{Chapitre 7:} +\section{Chapitre 7: Problème du flot maximum} \label{sec:ch7} +Référence: \cite{papadimitriou2013combinatorial} + +\subsection{Les graphes orientés} +\label{sec:graphesorientes} + +\begin{itemize} +\item Un graphe est un tuple $(V,E)$ formé de \textbf{sommets} $V$ et d'\textbf{arêtes} $E \subseteq V \times V$. +\item Une arête est représentée par une paire de sommets. Ces sommets sont \textbf{adjacents}. +\item Un graphe peut avoir des \textbf{poids} sur ses arêtes. +\item Un \textbf{chemin} est une suite de sommets distincts. Il a une \textbf{origine} et une \textbf{destination}. +\item Un \textbf{cycle} est une suite de sommets distincts dont le dernier sommet est adjacent au premier. +\item Liste de proximité: Tableau $Adj$ dont chaque élément $Adj[i]$ pointe sur une liste qui contient les sommets adjacents. Cette liste peut être doublement chaînée +\end{itemize} + +\subsection{Fouille en profondeur} +\label{sec:fouilleprofondeur} + +\begin{itemize} +\item Code de couleurs: Blanc=non visité, Gris=visite non complétée, Noir=visite complétée +\item Vecteur parent: Encode une forêt. $u$ est le parent de $v$ = $Parent[v]=u$ +\item Complexité: +\begin{table}[!ht] + \centering + \begin{tabular}{l|l} + Étape & Complexité \\ + \hline + Initialisation & $\mathcal{O}(|V|)$ \\ + Visite & $|V|$ \\ + Arête & $|E|$ \\ + \hline + \textbf{Total} & $\mathcal{O}(|V|+|E|)$ + \end{tabular} + \caption{Complexité de la fouille en profondeur} + \label{tab:compfouilleprof} +\end{table} +\end{itemize} + + +\begin{algorithm}[!ht] + \Deb{ + \PourTous{$u \in V$}{ + $Couleur[u] \leftarrow Blanc$ \; + $Parent[u] \leftarrow Nul$ \; + } + \PourTous{$u \in V$}{ + \Si{$Couleur[u]=Blanc$}{ + Visite$(u,V,E)$ \; + } + } + } +\caption{FouilleProfondeur$(V,E)$} +\end{algorithm} + +\begin{algorithm}[!ht] + \Deb{ + $Couleur[u]=Gris$ \; + \Pour{$v \in Adj[u]$}{ + \Si{$Couleur[u]=Blanc$}{ + $Parent[v] \leftarrow u$ \; + Visite$(v,V,E)$ \; + } + } + $Couleur[u]=Noir$ + } +\caption{Visite$(u,V,E)$} +\end{algorithm} + +Pour trouver un chemin entre $s$ et $t$, on exécute seulement la fouille en profondeur sur l'origine $s$. Si $t$ est nul, il n'y a pas de chemin de $s$ vers $t$. + +\subsection{Problème du flot maximum} +\label{sec:flotmaximum} + +Définition du problème: +\begin{itemize} +\item $s$: Source +\item $t$: Puits +\item $c(a,b)$: Capacité +\item $f(a,b)=-f(b,a)$: Flot +\item Instance: $FlotMaximum(G=(V,E),s,t,c)$ +\end{itemize} + +Contraintes: un flot valide satisfait ces contraintes +\begin{itemize} +\item Conservation du flot: + \begin{align} + \sum_{b \mid (b,a) \in E} f(b,a) &= \sum_{b \mid (a,b) \in E} f(a,b) & \forall a \in V \setminus \lbrace s,t \rbrace + \end{align} +\item Ce qui équivaut à: + \begin{align} + \sum_{b \in V} f(a,b) &= 0 & \forall a \in V \setminus \lbrace s,t \rbrace + \end{align} +\item Contrainte de capacité: + \begin{align} + f(a,b) &\leq c(a,b) & \forall (a,b) \in E \\ + f(a,b) &\leq 0 & \forall (a,b) \notin E + \end{align} +\end{itemize} + +Le problème du flot maximum consiste à trouver un flot valide dont la valeur est maximale +\begin{align} + v(f) &= \sum_{a \in V}f(s,a)\\ + &= \sum_{a \in V} f(a,t) +\end{align} + +Représentation graphique + +\begin{figure}[!ht] + \centering + \includegraphics[width=12cm]{exemple_flot} + \caption{Représentation graphique d'un flot} + \label{fig:grapheflot} +\end{figure} + +\subsection{Chemins augmentant} +\label{sec:cheminsaugmentant} + +Objectif: Identifier les chemins augmentants dans le graphe résiduel + +\paragraph{Graphe résiduel} +\begin{itemize} +\item Utilisé pour identifier les chemins reliant la source au puits +\item Mêmes noeuds que le graphe original, mais les arêtes peuvent avoir un poids et une orientation différente +\item Notation: $G_f = (V, E_f)$ +\item Existence d'une arête dans le graphe résiduel + \begin{align} + (a,b) \in E_{f} \iff f(a,b) < c(a,b) + c_f(a.b) = c(a,b) - f(a.b) + \end{align} +\item Chemin augmentant: relie la source au puits dans le graphe résiduel. Non nul +\end{itemize} + +Exemple de graphe résiduel (Figure \ref{fig:grapheresiduel}) + +\begin{figure}[h] + \centering + \includegraphics[width=7cm]{exemple_flot_residuel} + \caption{Graphe résiduel} + \label{fig:grapheresiduel} +\end{figure} + +\clearpage + +\subsection{Algorithme de Ford-Fulkerson} +\label{sec:fordfulkerson} + +\begin{algorithm}[h] + \Deb{ + \Pour{$i \in \binom{|V|}{2}$}{ + $f[i] \leftarrow 0$ + } + \Repeter{aucun chemin entre $s$ et $t$ dans $G_f$}{ + Construire $G_f$ \; + Trouver le chemin $C$ de $s$ à $t$ avec une fouille en profondeur \; + \Si{$\exists C$}{ + $q=min(c_f(a,b)) | (a,b) \in C$ \; + \PourTous{$(a,b) \in C$}{ + $f(a,b) \leftarrow f(a,b)+q$ \; + $f(b,a) \leftarrow f(b,a)-q$ \; + } + } + } + \Retour{f} \; + } +\caption{Ford-Fulkerson} +\end{algorithm} + +Complexité: + +\begin{table}[h] + \centering + \begin{tabular}{l|l} + Étape & Complexité \\ + \hline + Chemin dans le graphe résiduel & $\mathcal{O}(|V|+|E|), |V|-1 \leq |E| \rightarrow \mathcal{O}(|E|)$ \\ + Mise à jour du graphe résiduel & $\mathcal{O}(|V|)$ \\ + \hline + \textbf{Total} & $\mathcal{O}(v(f)|E|)$ + \end{tabular} + \caption{Complexité de Ford-Fulkerson} + \label{tab:compfouilleprof} +\end{table} + +\subsection{Coupe minimale} +\label{sec:coupeminimale} + +\begin{itemize} +\item Une coupe est une bipartition des noeuds tel que la source est dans $S$ et le puits dans $T$ +\item Capacité d'une coupe + \begin{align} + c(S,T) &= \sum_{a \in S} \sum_{b \in T} c(a,b) + \end{align} +\item Flot net d'une coupe: quantité de flot passant d'un noeud dans $S$ à un noeud dans $T$: + \begin{align} + f(S,T) &= \sum_{a\in S, b\in T} f(a,b) + \end{align} +\item Théorème: Pour toute coupe $(S,T)$ et tout flot valide $f$: $v(f)=f(S,T)$ +\end{itemize} + +Trois affirmations équivalentes: + +\begin{enumerate} +\item $f$ est un flot maximum dans $G$ +\item Le graphe résiduel $G_f$ n'a pas de chemin augmentant +\item Il existe une coupe $(S,T)$ dont la capacité $c(S,T)$ est égale a $v(f)$ +\end{enumerate} + +En résumé: + +\begin{itemize} +\item +\end{itemize} + +\subsection{Ordonnancement} +\label{sec:ordonnancement} + + %%% Local Variables: diff --git a/exemple_flot.dot b/exemple_flot.dot new file mode 100644 index 0000000..bf086aa --- /dev/null +++ b/exemple_flot.dot @@ -0,0 +1,10 @@ +digraph { + rankdir="LR"; + 1->2[label="3/3"] + 1->3[label="4/7"] + 2->4[label="2/2"] + 2->5[label="1/2"] + 3->5[label="4/4"] + 4->6[label="2/3"] + 5->6[label="5/5"] +} diff --git a/exemple_flot_residuel.dot b/exemple_flot_residuel.dot new file mode 100644 index 0000000..16b0353 --- /dev/null +++ b/exemple_flot_residuel.dot @@ -0,0 +1,5 @@ +digraph { + 1->3[label="3/7"] + 2->5[label="1/2"] + 4->6[label="1/3"] +} diff --git a/makefile b/makefile index b12038d..6581c74 100644 --- a/makefile +++ b/makefile @@ -1,10 +1,16 @@ build: notes_de_cours.pdf +exemple_flot.png: + dot -Tpng /media/francois/MEGA5TO/git/ift7020_notes_de_cours/exemple_flot.dot -o /media/francois/MEGA5TO/git/ift7020_notes_de_cours/exemple_flot.png + +exemple_flot_residuel.png: + dot -Tpng /media/francois/MEGA5TO/git/ift7020_notes_de_cours/exemple_flot_residuel.dot -o /media/francois/MEGA5TO/git/ift7020_notes_de_cours/exemple_flot_residuel.png + notes_de_cours.pdf: notes_de_cours.bbl pdflatex notes_de_cours.tex pdflatex notes_de_cours.tex -notes_de_cours.bbl: notes_de_cours.tex +notes_de_cours.bbl: notes_de_cours.tex exemple_flot.png exemple_flot_residuel.png pdflatex notes_de_cours.tex bibtex notes_de_cours.aux @@ -20,3 +26,5 @@ clean: -rm *.out -rm *.toc -rm *.pdf + -rm exemple_flot.png exemple_flot_residuel.png +