1428 lines
52 KiB
TeX
1428 lines
52 KiB
TeX
\chapter{Connectivité dans un graphe}
|
|
|
|
\section{Algorithme de Roy-Warshall}
|
|
|
|
\paragraph{Exercice page 101}
|
|
|
|
\tikzstyle{vertex}=[circle,fill=black!25,minimum size=20pt,inner sep=0pt]
|
|
\tikzstyle{edge} = [draw,thick,-]
|
|
\tikzstyle{weight} = [font=\small]
|
|
\tikzstyle{selected edge} = [draw,line width=5pt,-,red!50]
|
|
\tikzstyle{ignored edge} = [draw,line width=5pt,-,black!20]
|
|
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=3cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {A};
|
|
\node[main node] (2) [right of=1] {B};
|
|
\node[main node] (3) [right of=2] {C};
|
|
\node[main node] (4) [below of=2] {D};
|
|
\node[main node] (5) [below right of=3] {E};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge node[right] {$u_1$} (2)
|
|
edge node[left] {$u_2$} (4)
|
|
(2) edge node[left] {$u_3$} (3)
|
|
(3) edge node[left] {$u_4$} (5)
|
|
(4) edge node [left] {$u_5$} (3)
|
|
edge node[left] {$u_6$} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
|
|
Soit $M$ la \emph{matrice binaire} associée à un graphe.
|
|
|
|
\[
|
|
M= \begin{bmatrix}
|
|
0 & 1 & 0 & 1 & 0\\
|
|
0 & 0 & 1 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 1 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix}
|
|
\]
|
|
|
|
\subsubsection{Représenter le graphe associé.}
|
|
|
|
$M$ est la matrice $n\times n$ avec $n$ le nombre de sommets (ou n\oe uds) du
|
|
graphe.\\
|
|
|
|
Ici, on a 5 sommets~: $A$, $B$, $C$, $D$ et $E$.
|
|
$$m_{i,j}=1\Longleftrightarrow\exists\text{ un arc }(i,j)$$
|
|
|
|
\subsubsection{Donner la matrice d'incidence de ce graphe.}
|
|
|
|
Soit la matrice $A$~: $n\times m$, avec $n$ le nombre de \emph{sommets} du
|
|
graphe et $m$ le nombre \emph{d'arcs} du graphe.
|
|
|
|
\[
|
|
M=\bordermatrix{~ & u_1 & u_2 & u_3 & u_4 & u_5 & u_6 \cr
|
|
A & +1 & +1 & & & & \cr
|
|
B & -1 & & +1 & & & \cr
|
|
C & & & & +1 & -1 & \cr
|
|
D & & -1 & & & +1 & +1 \cr
|
|
E & & & & -1 & & -1 \cr}
|
|
\]
|
|
|
|
$a_{i,j}=+1$ si $i$ est à l'origine de l'arc $j$, $a_{i,j}=-1$ si $i$ est à
|
|
l'extrêmité terminale de $j$, $a_{i,j}=0$ sinon.
|
|
|
|
\subsubsection{Calculer $M^2$, $M^3$, $M^4$, \ldots et interpréter les termes non nuls de ces matrices.}
|
|
|
|
\[
|
|
M^2= \begin{bmatrix}
|
|
0 & 0 & 2 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix}
|
|
\]
|
|
|
|
$a_{3,1}=2$, cela signifie qu'il existe deux chemins de longueur 2 reliant $A$
|
|
à $C$~: $ABC$ et $ADC$.
|
|
$a_{5,1}=1$, cela signifie qu'il existe un chemin de longueur 2 reliant $A$
|
|
à $E$~: $ADE$.
|
|
|
|
\[
|
|
M^3= \begin{bmatrix}
|
|
0 & 0 & 0 & 0 & 2\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix}
|
|
\qquad
|
|
M^4= \begin{bmatrix}
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix} = M^n\quad\forall n\geq 4
|
|
\]
|
|
|
|
Grâce à $M^3$, on voit qu'il n'existe que deux chemins de longueur trois
|
|
reliant $A$ à $E$~: $ABCE$ et $ADCE$.
|
|
|
|
Il n'existe pas de chemin plus grand que 3, car on a une matrice nulle pour
|
|
$M^4$.
|
|
|
|
\subsubsection{Calculer les puissances booléennes de $M$, soit $M^{\left[2\right]}$,
|
|
$M^{\left[3\right]}$, $M^{\left[4\right]}$, \ldots}
|
|
|
|
\[
|
|
M^{\left[2\right]}= \begin{bmatrix}
|
|
0 & 0 & 1 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix}
|
|
\qquad
|
|
M^{\left[3\right]}= \begin{bmatrix}
|
|
0 & 0 & 0 & 0 & 1\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0\\
|
|
0 & 0 & 0 & 0 & 0
|
|
\end{bmatrix}
|
|
\]
|
|
|
|
Dans ce cas, on dit qu'il existe au moins un chemin de longueur deux reliant
|
|
les points où l'intersection dans la matrice n'est pas nulle.\\
|
|
On a perdu l'information du nombre de chemin, on sait seulement si un chemin
|
|
existe ou non.
|
|
|
|
\subsubsection{Calculer la fermeture réflexo-transitive du graphe.}
|
|
|
|
$$B=I\dot{+}M\dot{+}M^{\left[2\right]}\dot{+}\ldots$$
|
|
|
|
\[
|
|
I= \begin{bmatrix}
|
|
1 & 0 & 0 & 0 & 0\\
|
|
0 & 1 & 0 & 0 & 0\\
|
|
0 & 0 & 1 & 0 & 0\\
|
|
0 & 0 & 0 & 1 & 0\\
|
|
0 & 0 & 0 & 0 & 1
|
|
\end{bmatrix}\text{ la matrice identitée}
|
|
\]
|
|
|
|
\paragraph{En clair~:} $B$ correspond en fait à un OU logique appliqué à
|
|
l'ensemble des matrices.
|
|
|
|
\[
|
|
B= \begin{bmatrix}
|
|
1 & 1 & 1 & 1 & 1\\
|
|
0 & 1 & 1 & 0 & 1\\
|
|
0 & 0 & 1 & 0 & 1\\
|
|
0 & 0 & 1 & 1 & 1\\
|
|
0 & 0 & 0 & 0 & 1
|
|
\end{bmatrix}
|
|
\]
|
|
|
|
Pour chacun des éléments non nuls de la matrice $B$, on peut dire qu'il existe
|
|
au moins un chemin (de longueur indéterminée). La matrice $B$ permet donc de
|
|
savoir si deux sommets sont interconnectés dans le graphe.
|
|
|
|
\subsubsection{Algorithme de Roy-Warshall.}
|
|
|
|
L'algorithme de Roy-Warshall permet de calculer $B$ sans calculer les produits
|
|
matriciels.
|
|
|
|
\subsection{Étapes}
|
|
\begin{itemize}
|
|
\item On calcul $B=I\dot{+}M$~;
|
|
\item On calcul l'image de $B$ par l'opérateur $\theta_1$, soit
|
|
$B=\theta_1(B)$~;
|
|
\item On calcul l'image de $B$ par l'opérateur $\theta_2$~;
|
|
\item Ainsi de suite, jusqu'à $\theta_n$.
|
|
\end{itemize}
|
|
|
|
\subsection{Opérateur $\theta_i$}
|
|
|
|
\begin{itemize}
|
|
\item On considère toutes les lignes de $B$ qui ont un 1 en colonne $i$~;
|
|
\item On ajoute (addition booléenne $\dot{+}$) à chacune de ces lignes tous les 1 de la ligne $i$~;
|
|
\end{itemize}
|
|
|
|
\[
|
|
B=\theta_1(B)=
|
|
\begin{bmatrix}
|
|
1 & \textbf{1} & 0 & 1 & 0\\
|
|
0 & \textbf{1} & \textbf{1} & 0 & 0\\
|
|
0 & \textbf{0} & 1 & 0 & 1\\
|
|
0 & \textbf{0} & 1 & 1 & 1\\
|
|
0 & \textbf{0} & 0 & 0 & 1
|
|
\end{bmatrix}
|
|
\xrightarrow{\theta_2}
|
|
\begin{bmatrix}
|
|
1 & 1 & \textbf{1} & 1 & 0\\
|
|
0 & 1 & \textbf{1} & 0 & 0\\
|
|
0 & 0 & \textbf{1} & \textbf{0} & \textbf{1}\\
|
|
0 & 0 & \textbf{1} & 1 & 1\\
|
|
0 & 0 & \textbf{0} & 0 & 1
|
|
\end{bmatrix}
|
|
\xrightarrow{\theta_3}
|
|
\begin{bmatrix}
|
|
1 & 1 & 1 & 1 & \textbf{1}\\
|
|
0 & 1 & 1 & 0 & \textbf{1}\\
|
|
0 & 0 & 1 & 0 & \textbf{1}\\
|
|
0 & 0 & 1 & 1 & \textbf{1}\\
|
|
0 & 0 & 0 & 0 & \textbf{1}
|
|
\end{bmatrix}
|
|
\]
|
|
|
|
\paragraph{Exercice 2 page 101}
|
|
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=3cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {A};
|
|
\node[main node] (2) [right of=1] {B};
|
|
\node[main node] (3) [below right of=2] {C};
|
|
\node[main node] (4) [below left of=3] {D};
|
|
\node[main node] (6) [below left of=1] {F};
|
|
\node[main node] (5) [below right of=6] {E};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [bend right] node[right] {} (2)
|
|
edge [bend right] node[left] {} (6)
|
|
(2) edge [bend right] node[left] {} (1)
|
|
edge [loop] node {} (2)
|
|
edge [bend left] node[left] {} (3)
|
|
edge [bend left] node[left] {} (5)
|
|
(3) edge [bend right] node[left] {} (4)
|
|
(4) edge [right] node [left] {} (2)
|
|
edge [bend right] node[left] {} (3)
|
|
edge [bend left] node[left] {} (5)
|
|
(5) edge [loop] node [left] {} (5)
|
|
edge [bend left] node[left] {} (6)
|
|
edge [bend left] node[left] {} (2)
|
|
(6) edge node [left] {} (3)
|
|
edge [bend right] node[left] {} (1)
|
|
;
|
|
\end{tikzpicture}
|
|
|
|
\subsubsection{Calculer les demi-degrés extérieurs et intérieurs des sommets du graphe}
|
|
|
|
$\Gamma^+(A),\Gamma^+(B),\ldots$~; $\Gamma^+(A)={B,F}$, $\Gamma^+(B)={A,B,C,E}$, \ldots
|
|
|
|
$\Gamma^-(A),\Gamma^-(B),\ldots$~; $\Gamma^-(A)={B,F}$, $\Gamma^+(B)={A,B,C,E}$, \ldots\\
|
|
|
|
$\Gamma^+$~: la liste des descendants immédiats de $i$ et $\Gamma^+$~: la liste
|
|
des prédécesseurs immédiats de $i$.\\
|
|
|
|
\textbf{Le demi-degré intérieur} du sommet $i$ $\leftarrow d'(i)$~: le nombre
|
|
de prédécesseurs immédiats de $i$, à l'exception de $i$ lui-même.
|
|
|
|
\textbf{Le demi-degré extérieur} du sommet $i$ $\leftarrow d''(i)$~: le nombre
|
|
de successeurs immédiats de $i$, à ;'exception de $i$ lui-même.\\
|
|
|
|
$\Gamma^+(A)={B,F}$~: $d''(A)=2$
|
|
|
|
$\Gamma^+(B)={A,B,D,E}$~: $d''(B)=3$
|
|
|
|
\subsubsection{Donner un exemple de chemin simple mais non élémentaire.}
|
|
|
|
Un \textbf{chemin est simple} s'il ne passe qu'une fois par l'ensemble de ces
|
|
arcs. Exemple~: $ABCDBE$.
|
|
|
|
Un \textbf{chemin est élémentaire} s'il ne passe qu'une fois par l'ensemble de ces
|
|
sommets.
|
|
|
|
\subsubsection{Existe-il un circuit Hamiltonien dans ce graphe~?}
|
|
|
|
Un \textbf{circuit} est un chemin qui se ferme sur lui-même.
|
|
|
|
Un \textbf{circuit hamiltonien} est un circuit passant par tous les sommets du
|
|
graphe.
|
|
|
|
\subparagraph{Problème du voyageur de commerce} Le voyageur de commerce visite
|
|
une fois et une seul chaque ville, puis retourne à la ville de départ.
|
|
|
|
\section{Recherche de plus court chemin optimal}
|
|
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=3cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (3) {C};
|
|
\node[main node] (1) [below left of=3] {A};
|
|
\node[main node] (2) [below right of=2] {B};
|
|
\node[main node] (4) [below of=3] {D};
|
|
\node[main node] (5) [right of=2] {E};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge node[right] {4} (3)
|
|
edge node[left] {8} (4)
|
|
(2) edge node[left] {2} (5)
|
|
edge [bend left] node[left] {2} (4)
|
|
(3) edge [bend left] node[left] {3} (2)
|
|
edge [bend right] node[left] {4} (4)
|
|
(4) edge [bend right] node [left] {-6} (3)
|
|
edge [bend right] node[left] {1} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
|
|
\subsection{Méthode matricielle}
|
|
|
|
Pas de sommet source.
|
|
|
|
Cette méthode donne en une seule exécution le chemin le plus court ou le chemin
|
|
le plus long entre deux sommets.
|
|
|
|
On cherche le chemin de valeur maximale reliant deux sommets.
|
|
|
|
\subsubsection{Initialisation}
|
|
On considère deux matrices $D_0$ et $\Pi_0$, de dimension $n\times n$, avec $n$
|
|
le nombre de sommets (ici 5).
|
|
|
|
\[
|
|
D_0=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & -\infty & -\infty & 4 & 8 & -\infty \cr
|
|
B & -\infty & -\infty & -\infty & 2 & 2 \cr
|
|
C & -\infty & 3 & -\infty & 4 & -\infty \cr
|
|
D & -\infty & -\infty & -6 & -\infty & 1 \cr
|
|
E & -\infty & -\infty & -\infty & -\infty & -\infty \cr}
|
|
\qquad
|
|
\Pi_0=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & 1 & 1 & 1 & 1 & 1 \cr
|
|
B & 2 & 2 & 2 & 2 & 2 \cr
|
|
C & 3 & 3 & 3 & 3 & 3 \cr
|
|
D & 4 & 4 & 4 & 4 & 4 \cr
|
|
E & 5 & 5 & 5 & 5 & 5 \cr}
|
|
\]
|
|
|
|
$(D_0)_{i,j}=v_{i,j}=$ la valeur de l'arc $(i,j)$ si cet arc est présent\newline
|
|
sinon $(D_0)_{i,j}=-\infty$\newline
|
|
$(\Pi_{ij})=i$, $\forall j$.
|
|
|
|
\subsubsection{À chaque étape $k\geq 1$}
|
|
|
|
On calcule la matrice $D_k$ obtenue en remplaçant $(D_{k-1})_{i,j}$ par
|
|
$\max\lbrace(D_{k-1})_{i,j}, x\rbrace$, $x$ correspond à la somme du $k$-ième
|
|
terme de la ligne et du $k$-ième terme de la colonne où se trouve
|
|
$(D_k)_{i,j}$.
|
|
|
|
On itére pour $k=1,2,\ldots,n$. Ici $n=5\longmapsto$ on lit le résultat cherché
|
|
par l'intermédiaire des matrices $(D_n, \Pi_n)$.
|
|
|
|
\[
|
|
D_1=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & -\infty & -\infty & 4 & 8 & -\infty \cr
|
|
B & -\infty & -\infty & -\infty & 2 & 2 \cr
|
|
C & -\infty & 3 & -\infty & \textbf{4} & -\infty \cr
|
|
D & -\infty & -\infty & -6 & -\infty & 1 \cr
|
|
E & -\infty & -\infty & -\infty & -\infty & -\infty \cr}
|
|
\qquad
|
|
\Pi_1=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & 1 & 1 & 1 & 1 & 1 \cr
|
|
B & 2 & 2 & 2 & 2 & 2 \cr
|
|
C & 3 & 3 & 3 & \textbf{3} & 3 \cr
|
|
D & 4 & 4 & 4 & 4 & 4 \cr
|
|
E & 5 & 5 & 5 & 5 & 5 \cr}
|
|
\]
|
|
$\max\lbrace4,-\infty+8\rbrace$. La première colonne étant composée de
|
|
$-\infty$, les deux matrices sont identiques. On a $D_0\equiv D_1$ et
|
|
$\Pi_0\equiv \Pi_1$.
|
|
|
|
\[
|
|
D_2=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & -\infty & -\infty & 4 & 8 & -\infty \cr
|
|
B & -\infty & -\infty & -\infty & 2 & 2 \cr
|
|
C & -\infty & 3 & -\infty & \textbf{5} & \textbf{5} \cr
|
|
D & -\infty & -\infty & -6 & -\infty & 1 \cr
|
|
E & -\infty & -\infty & -\infty & -\infty & -\infty \cr}
|
|
\qquad
|
|
\Pi_2=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & 1 & 1 & 1 & 1 & 1 \cr
|
|
B & 2 & 2 & 2 & 2 & 2 \cr
|
|
C & 3 & 3 & 3 & \textbf{2} & \textbf{2} \cr
|
|
D & 4 & 4 & 4 & 4 & 4 \cr
|
|
E & 5 & 5 & 5 & 5 & 5 \cr}
|
|
\]
|
|
Dans $\Pi_2$~: $(\Pi_2)_{i,j}=(\Pi)_{2,j}$
|
|
|
|
\[
|
|
D_3=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & -\infty & \textbf{7} & 4 & \textbf{9} & \textbf{9} \cr
|
|
B & -\infty & -\infty & -\infty & 2 & 2 \cr
|
|
C & -\infty & 3 & -\infty & 5 & 5 \cr
|
|
D & -\infty & \textbf{-3} & -6 & \textbf{-1} & 1 \cr
|
|
E & -\infty & -\infty & -\infty & -\infty & -\infty \cr}
|
|
\qquad
|
|
\Pi_3=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & 1 & \textbf{3} & 1 & \textbf{2} & \textbf{2} \cr
|
|
B & 2 & 2 & 2 & 2 & 2 \cr
|
|
C & 3 & 3 & 3 & 2 & 2 \cr
|
|
D & 4 & \textbf{3} & 4 & \textbf{2} & 4 \cr
|
|
E & 5 & 5 & 5 & 5 & 5 \cr}
|
|
\]
|
|
|
|
\[
|
|
D_4=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & -\infty & 7 & 4 & 9 & \textbf{10} \cr
|
|
B & -\infty & \textbf{-1} & \textbf{-4} & 2 & \textbf{3} \cr
|
|
C & -\infty & 3 & \textbf{-1} & 5 & \textbf{6} \cr
|
|
D & -\infty & -3 & -6 & -1 & 1 \cr
|
|
E & -\infty & -\infty & -\infty & -\infty & -\infty \cr}
|
|
\qquad
|
|
\Pi_4=\bordermatrix{~ & A & B & C & D & E \cr
|
|
A & 1 & 3 & 1 & 2 & \textbf{4} \cr
|
|
B & 2 & \textbf{3} & \textbf{4} & 2 & \textbf{4} \cr
|
|
C & 3 & 3 & \textbf{4} & 2 & \textbf{4} \cr
|
|
D & 4 & 3 & 4 & 2 & 4 \cr
|
|
E & 5 & 5 & 5 & 5 & 5 \cr}
|
|
\]
|
|
|
|
La dernière ligne étant composée de $=-\infty$, $D_5\equiv D_4$ et
|
|
$\Pi_5\equiv\Pi_4$.
|
|
|
|
\subsubsection{Lecture du résultat via $D_5$ et $\Pi_5$}
|
|
|
|
On lit dans la case $(D_n)_{i,j}$ la valeur du chemin le plus long reliant $i$
|
|
à $j$. Exemple~: le chemin le plus long allant de $A$ à $E$ est de longueur
|
|
10.\\
|
|
|
|
$(\Pi_n)_{i,j}$ est le prédécesseur immédiat de $j$, soit $j'$.
|
|
|
|
$(\Pi_n)_{i,j'}$ est le prédécesseur immédiat de $j'$, soit $j''$, \ldots
|
|
|
|
\paragraph{Remarque} Le même algorithme procure également les chemins les plus
|
|
courts en appliquant deux changements~:
|
|
\begin{itemize}
|
|
\item \textbf{Initialisation~:} on initialise la matrice à $+\infty$ au lieu
|
|
de $-\infty$.
|
|
\item \textbf{À l'itération $k$~:} on remplace l'opération $\max$ par
|
|
$\min$.
|
|
\end{itemize}
|
|
|
|
%Deuxième cours
|
|
\chapter{Problèmes d'ordonnancement de projets}
|
|
|
|
%%%
|
|
%Théorie des graphes -> cas déterministe.
|
|
%Un projet -> plusieurs tâches.
|
|
%Toutes ces tâches sont liées par des \textbf{contraintes}.
|
|
%\underline{But :} terminer au plus tôt, en respectant les contraintes.
|
|
%%%
|
|
|
|
Le but est de trouver l'ordonnancement au plus tôt de toutes les tâches.
|
|
|
|
On représente généralement ce genre de problème sous la forme de diagrammes de
|
|
Gantt calés à gauche.
|
|
|
|
Le deuxième objectif est de déterminer le chemin critique~: tout retard sur une
|
|
tâche critique se représente sur la durée totale du projet.
|
|
|
|
Pour les tâches non-critiques, on peut calculer la marge totale et la marge
|
|
libre.\\
|
|
|
|
Il existe deux méthodes principales pour calculer les crontraites de type
|
|
\emph{potentiel}~: la méthode tâche et la méthode PERT (qui ne sera pas traitée
|
|
dans ce cours).
|
|
|
|
Les seules contraintes sont du type~: \og la tâche B ne peut démarrer que 3
|
|
jours après la tâche A\fg, contraintes de succession.
|
|
|
|
\paragraph{Remarque} les contraintes les plus dures ne sont pas prises en
|
|
compte~: on parle de type cumulatif.
|
|
|
|
Lorsque les ressources sont limités, les interactions sont très fortes entre
|
|
les tâches.
|
|
|
|
%Permet au tableau d'être où il faut.
|
|
\newpage
|
|
\section{Méthode portentiels-tâches}
|
|
|
|
%2 opérations :
|
|
%\underline{1 - Ordonnancement au plus tôt}
|
|
%On calcule les dates de début au plus tôt de toutes les tâches
|
|
%=> diagramme de GANT calé à gauche.
|
|
%
|
|
%=> il y a 2 sortes de tâches :
|
|
% *les tâches critiques.
|
|
% *les tâches non-critiques.
|
|
%Une tâche critique est une tâche qui ne souffre d'aucun retard.
|
|
%-> tout retard sur le démarrage d'une tâche critique se répercurte
|
|
%\underline{sur la date de fin du projet}.
|
|
%Pour les tâches non critiques, il existe des marges totales/libres.
|
|
%\underline{2 - Ordonnancement au plus tard}
|
|
%\underline{hypothèse :} la durée minimale du projet est respectée.
|
|
%On cherche \underline{la date de début au plus tard} de chaque tâche
|
|
%non-critique, qui soit compatible avec cette durée minimale du projet.
|
|
\paragraph{Exemple} On a un problème à 7 tâches ($a$, $b$, $c$, $d$, $e$, $f$
|
|
et $g$)~; les contraintes sont de type portentiel seulement.
|
|
|
|
|
|
Soit le tableau des contraintes suivantes~:
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tabular}{c|c|c}
|
|
\textbf{Tâches} & \textbf{Durées} & \textbf{Contraintes}\\
|
|
\hline
|
|
$a$ & 6 & \\
|
|
$b$ & 3 & \\
|
|
$c$ & 6 & \\
|
|
$d$ & 2 & $b$ achevée\\
|
|
$e$ & 4 & $b$ achevée\\
|
|
$f$ & 3 & $a$ et $d$ achevées\\
|
|
$g$ & 1 & $c$, $e$ et $f$ achevées\\
|
|
\end{tabular}
|
|
\end{figure}
|
|
|
|
\subsection{Ordonancement au plus tôt -- Algorithme de Bellman}
|
|
|
|
On peut représenter le tableau des contraintes à l'aide d'un graphe, le graphe
|
|
\emph{potentiels-tâches}, dans lequel~:
|
|
|
|
\begin{itemize}
|
|
\item un sommet est associé à chaque tâche~;
|
|
\item un sommet $\alpha$ que l'on associe au début du projet~;
|
|
\item un sommet $\omega$ qui sera la fin du projet.
|
|
\end{itemize}
|
|
|
|
On aura un arc $i,j$ si la tâche $j$ ne peut démarrer qu'après la tâche $i$. Il
|
|
s'agit d'une contrainte d'antécédence entre tâches.
|
|
|
|
La valuation de l'arc $i,j$~: le plus souvent, c'est la durée de la tâche $i$.
|
|
La tâche $j$ ne peut démarrer que lorsque la tâche $i$ est achevée~: entre le
|
|
début de la tâche $j$ et le début de la tâche $i$ qui la précéde s'écoule le
|
|
temps d'exécution de la tâche $i$.
|
|
|
|
\paragraph{Remarque} On peut rencontrer le contraire~: \og $j$ ne peut démarrer
|
|
que 2 jours après le début de $i$\fg. Dans ce cas, l'arc $i,j$ sera valué par
|
|
2.
|
|
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=3cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (2) {$a$};
|
|
\node[main node] (3) [below of=2] {$b$};
|
|
\node[main node] (1) [left of=3] {$\alpha$};
|
|
\node[main node] (4) [below of=3] {$c$};
|
|
\node[main node] (5) [right of=3] {$d$};
|
|
\node[main node] (6) [below of=5] {$e$};
|
|
\node[main node] (7) [right of=5] {$f$};
|
|
\node[main node] (8) [below of=7] {$g$};
|
|
\node[main node] (9) [right of=7] {$\omega$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [right] node[right] {0} (2)
|
|
edge [right] node[left] {0} (3)
|
|
edge [right] node[left] {0} (4)
|
|
(2) edge [right] node[right] {6} (7)
|
|
(3) edge [right] node[right] {3} (5)
|
|
edge [right] node[left] {3} (6)
|
|
(4) edge [bend right] node[right] {6} (8)
|
|
(5) edge [right] node[right] {2} (7)
|
|
(6) edge [right] node[right] {4} (8)
|
|
(7) edge [right] node[right] {3} (8)
|
|
(8) edge [right] node[right] {1} (9)
|
|
;
|
|
\end{tikzpicture}
|
|
|
|
La durée minimale correspond au chemin le plug long entre $\alpha$ et
|
|
$\omega$.
|
|
|
|
\subsection{Algorithme de Bellman}
|
|
|
|
On commence par dresser le tableau suivant~:
|
|
|
|
\hspace{-1cm}
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
|
|
\hline
|
|
& {\color{mauve} 0} & {\color{dkgreen} 0} & {\color{dkgreen} 0} &
|
|
{\color{dkgreen} 0} & {\color{red} 3} & {\color{red} 3} & {\color{red} 6} &
|
|
{\color{red} 9} & {\color{red} 10} \\
|
|
\hline
|
|
Tâche & $\alpha$ & $a$ & $b$ & $c$ & $d$ & $e$ & $f$ & $g$ & $\omega$\\
|
|
\hline
|
|
Prédécesseurs & & {\color{mauve} 0} $\alpha$~: 0 & {\color{mauve} 0}
|
|
$\alpha$~: 0 & {\color{mauve} 0} $\alpha$~: 0 & {\color{blue} 0} $b$~: 3 &
|
|
{\color{blue} 0} $b$~: 3 & $\psi=$ {\color{blue} 0} $a$~: 6 & {\color{blue}
|
|
0} $c$~: 6 & {\color{blue} 9} $g$~: 1\\
|
|
&&&&&&& $\chi=$ {\color{blue} 3} $d$~: 2 & {\color{blue} 3} $e$~: 4&\\
|
|
&&&&&&&& {\color{blue} 6} $f$~: 3&\\
|
|
\hline
|
|
\end{tabular}
|
|
|
|
\paragraph{Initialisation} Le projet démarre à la date 0. Il s'agit de la date
|
|
de début au plus tôt de $\alpha$~; ici {\color{mauve} 0}.
|
|
|
|
\paragraph{Deuxième phase} {\color{mauve} Mouvement de haut en bas.}\\
|
|
Dès que l'on connaît une date de début au plus tôt (1\iere{} ligne du tableau),
|
|
on la répercute dans la deuxième ligne du tableau partout où la tâche concernée
|
|
apparaît.
|
|
|
|
\subparagraph{Ensuite} {\color{dkgreen} mouvement de bas en haut.}\\
|
|
Dès que l'on connaît les dates de début au plus tôt de tous les prédécesseurs
|
|
d'une tâche, on dit que la colonne est complète, et on calcule la date de
|
|
début au plus tôt de la tâche en tête de colonne (première ligne) par la
|
|
formule de Bellman~:
|
|
|
|
$$t_j=\max[t_i+v_{ij}]\qquad i\in(\Gamma^{-1}(j))$$
|
|
|
|
Par exemple, dans la colonne $f$, $\psi$ et $\chi$ sont $t_i$ et 6 et 2 sont $v_{ij}$
|
|
|
|
\begin{itemize}
|
|
\item $t_j$~: la date de début au plus tôt de $j$~;
|
|
\item $v_{ij}$~: valuation de l'arc $(i,j)$~;
|
|
\item $\Gamma^{-1}$~: prédécesseur de $j$.
|
|
\end{itemize}
|
|
|
|
{\color{blue} Ensuite}
|
|
|
|
{\color{red} Ensuite}
|
|
|
|
\vspace{1.5em}
|
|
|
|
L'ordonnancement au plus tôt est donc la durée minimale du projet, soit la date
|
|
au plus tôt de $\omega$ = 10~jours.
|
|
|
|
\begin{gantt}{8}{10}
|
|
\begin{ganttitle}
|
|
\numtitle{1}{1}{10}{1}
|
|
\end{ganttitle}
|
|
\ganttbar{$a$}{0}{6}
|
|
\ganttbar{$b$}{0}{3}
|
|
\ganttbar{$c$}{0}{6}
|
|
\ganttbar{$d$}{3}{2}
|
|
\ganttbar{$e$}{3}{4}
|
|
\ganttbar{$f$}{6}{3}
|
|
\ganttbar{$g$}{9}{1}
|
|
\ganttcon{6}{1}{6}{6}
|
|
\ganttcon{9}{6}{9}{7}
|
|
\end{gantt}
|
|
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {$\alpha$};
|
|
\node[main node] (2) [right of=1] {$a$};
|
|
\node[main node] (3) [right of=2] {$f$};
|
|
\node[main node] (4) [right of=3] {$g$};
|
|
\node[main node] (5) [right of=4] {$\omega$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [right] node[right] {0} (2)
|
|
(2) edge [right] node[right] {6} (3)
|
|
(3) edge [right] node[right] {3} (4)
|
|
(4) edge [right] node[right] {1} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Chemin critique}
|
|
\end{figure}
|
|
|
|
\vspace{1.5em}
|
|
|
|
On s'intéresse à l'ordonancement au plud tard, pour calculer les marges de
|
|
toutes les tâches non critiques.
|
|
|
|
\subparagraph{Hypothèse} La durée minimale du projet est respectée.
|
|
|
|
Pour les tâches critiques, la date de début au plus tard est égale à la date
|
|
de début au plus tôt.
|
|
|
|
Quelles sont les dates de début au plus tard des tâches non critiques~?
|
|
|
|
\vspace{1em}
|
|
|
|
\hspace{-1.5cm}
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
|
|
\hline
|
|
& 0 & 0 & 1 & 3 & 4 & 5 & 6 & 9 & 10\\
|
|
\hline
|
|
Tâche & $\alpha$ & $a$ & $b$ & $c$ & $d$ & $e$ & $f$ & $g$ & $\omega$\\
|
|
\hline
|
|
Successeurs & {\color{blue} 0} $a$~: 0 & {\color{blue} 6} $f$~: 6 &
|
|
{\color{blue} 4} $d$~: 3 & {\color{blue} 9} $g$~: 6 & {\color{blue} 6} $f$~:
|
|
2 & {\color{blue} 9} $g$~: 4 & {\color{blue} 9} $g$~: 3 & {\color{blue} 10}
|
|
$\omega$~: 1&\\
|
|
& {\color{blue} 1} $b$~: 0 & & {\color{blue} 5} $e$~: 3 &&&&&&\\
|
|
& {\color{blue} 3} $c$~: 0 &&&&&&&&\\
|
|
\hline
|
|
\end{tabular}
|
|
\vspace{1em}
|
|
|
|
Pour les tâches critiques~:
|
|
$$t_a^*=t_a=0$$
|
|
$$t_f^*=t_f=6$$
|
|
$$t_g^*=t_g=9$$
|
|
|
|
Pour les tâches non-critiques~: la \emph{marge totale} = $M_i=t_i^*-t_i$, soit~:
|
|
$$M_b=1$$
|
|
$$M_c=3$$
|
|
$$M_d=1$$
|
|
$$M_e=2$$
|
|
|
|
La \emph{marge libre}, $m_i$, est le délai dont on peut retarder la tâche $i$
|
|
sans conséquence sur ses successeurs.
|
|
$$m_i=\min(t_j-t_i-v_{ij})\qquad j\in\Gamma(i)$$
|
|
|
|
$$m_b=\min_{d,e}\lbrace t_d-t_b-v_{bd};t_e-t_b-v_{be}\rbrace$$
|
|
$$=\min_{d,e}\lbrace 3-0-3;3-0-3\rbrace=0$$
|
|
|
|
\subsection{Deuxième application~: algorithme de Ford}
|
|
|
|
Cet algorithme permet de trouver le chemin le plus long, ou le chemin le plus
|
|
court entre un sommet particulier (la racine) et tous les autres sommets du
|
|
graphe.
|
|
|
|
\paragraph{Initialisation} On numérote les sommets, le sommet racine prennant
|
|
le numéro 1. On essaye de respecter autant que possible la numérotation
|
|
topologique des sommets.
|
|
Les arcs de numérotation non topologique risquent d'entrainer
|
|
des retours en arrière ce qui impliquerait des retards.
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {$i$};
|
|
\node[main node] (2) [right of=1] {$j$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [right] node[right] {} (2)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Représentation topologique~; ici $i<j$}
|
|
\end{figure}
|
|
|
|
|
|
|
|
%À mettre en page ou à supprimer
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {$1$};
|
|
\node[main node] (2) [below right of=1] {$2$};
|
|
\node[main node] (3) [right of=2] {$3$};
|
|
\node[main node] (4) [below left of=1] {$4$};
|
|
\node[main node] (5) [below left of=2] {$5$};
|
|
\node[main node] (6) [below right of=2] {$6$};
|
|
\node[main node] (7) [right of=6] {$7$};
|
|
\node[main node] (8) [right of=7] {$8$};
|
|
\node[main node] (9) [right of=8] {$9$};
|
|
\node[main node] (10) [below right of=7] {$10$};
|
|
\node[main node] (11) [right of=5] {$11$};
|
|
\node[main node] (12) [right of=4] {$12$};
|
|
\node[main node] (13) [right of=1] {$13$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [right] node[right] {2} (2)
|
|
edge [right] node[right] {10} (3)
|
|
edge [bend left] node[right] {1} (4)
|
|
(2) edge [bend right] node[right] {3} (6)
|
|
edge [bend left] node[right] {20} (5)
|
|
(3) edge [bend right] node[right] {40} (5)
|
|
edge [bend left] node[right] {20} (4)
|
|
(4) edge [bend right] node[right] {3} (10)
|
|
edge [bend left] node[right] {5} (11)
|
|
(5) edge [bend right] node[right] {20} (6)
|
|
edge [right] node[right] {35} (7)
|
|
edge [bend left] node[right] {20} (9)
|
|
(6) edge [bend right] node[right] {5} (7)
|
|
(7) edge [bend left] node[right] {10} (8)
|
|
(8) edge [bend right] node[right] {45} (9)
|
|
edge [right] node[right] {20} (12)
|
|
(9) edge [bend left] node[right] {40} (12)
|
|
edge [bend right] node[right] {45} (11)
|
|
(10) edge [bend right] node[right] {45} (13)
|
|
(11) edge [right] node[right] {10} (10)
|
|
(12) edge [bend right] node[right] {10} (13)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Graphe page 106}
|
|
\end{figure}
|
|
Voir graphe page 106.
|
|
|
|
On cherche le chemin le plus court allant du sommet 1 vers tous les autres
|
|
sommets.
|
|
|
|
\paragraph{Marquage des sommets} On affecte au sommet 1 la valeur $\lambda_1=0$
|
|
et à tous les autres sommets la valeur $\lambda_i=+\infty$.
|
|
|
|
\begin{itemize}
|
|
\item $\lambda_i$ évolue en cours d'algorithme~;
|
|
\item le dernier $\lambda_i$ affecté à $i$ donne la longueur du chemin le
|
|
plus court allant du sommet 1 au sommet $i$.
|
|
\end{itemize}
|
|
|
|
\vspace{1em}
|
|
|
|
On examine à tour de rôle tous les arcs partant du sommet $i$, en commençant
|
|
par $i=1$. Pour ne pas en oublier, on fait cet examen dans l'ordre croissant de
|
|
l'extrémité $j$.
|
|
\vspace{1em}
|
|
Au moment de l'examen de l'arc $(i,j)$~: $v(i,j)$ est la valuation de l'arc
|
|
$(i,j)$.
|
|
|
|
Si $v(i,j)<\lambda_i-\lambda_j$, alors on remplace $\lambda_j$ par
|
|
$\lambda_i+v(i,j)$.
|
|
|
|
Si à un moment donné, on a $i>j$ et un changement de valeur pour $\lambda_j$,
|
|
il faut recommencer une partie des opérations, en repartant du sommet $i=j$. On
|
|
appel cela un retour en arrière.
|
|
|
|
|
|
\subparagraph{Par exemple} examen de l'arc $(11,10)$.
|
|
|
|
Cet examen risque d'entraîner le changement de valeur de $\lambda_{10}$. Alors,
|
|
il faut reprendre l'examen de l'arc $(10,13)$ avec la nouvelle valeur
|
|
$\lambda_{10}$.
|
|
|
|
\subparagraph{Go~!} examen de l'arc $(1,2)$.
|
|
$2 < \infty - 0$~? Oui $\Rightarrow$ on remplace $\lambda_2$ par
|
|
$\lambda_1+v(1,2)=0+2=2$.
|
|
|
|
\subparagraph{Remarque} Dans cet exemple, pas de retour en arrière, bien qu'un arc
|
|
ait ses extrêmités avec une numérotation non topologique. L'examen de l'arc
|
|
$(11,10)$ n'a pas entraîné la modification de $\lambda_{10}$. On ne doit pas
|
|
reaire l'examen de l'arc $(10,13)$.
|
|
|
|
\paragraph{Phase 2} identification du chemin solution.
|
|
|
|
On par de l'extrêmité terminale soit $i$. Le prédécesseur de $i$ est le sommet
|
|
$i$ tel que~:
|
|
$$\lambda_i-\lambda_{i'}=v(i',i)$$
|
|
|
|
|
|
% cours du 29/05 et du 04/06
|
|
\section{Programme de transport optimal}
|
|
|
|
\paragraph{Définition} Soit un graphe biparti avec \verb+m+ les
|
|
origines ou dépôts et \verb+n+ les destinataires ou clients.
|
|
|
|
On veut acheminer des marchandises depuis les dépôts jusqu'aux clients.
|
|
|
|
\subparagraph{Hypothèses} le \emph{coût unitaire} de transport est
|
|
donné depuis chaque dépôt vers chaque client~: $C_{ij}=$ coût de
|
|
transport d'une tonne depuis \verb+i+ vers \verb+j+ $\rightarrow[C]$.
|
|
|
|
\[
|
|
X=\bordermatrix{~ & 1 & 2 & 3 & 4 & 5 & 6 & ~\cr
|
|
I & & & 18 & & & & {\color{yellow}18}\cr
|
|
II & 9 & 11 & 7 & & & 5 & {\color{yellow}32}\cr
|
|
III & & & 3 & 6 & 5 & & {\color{yellow}14}\cr
|
|
IV & & & & & 9 &&{\color{yellow}9}\cr
|
|
~ & {\color{yellow}9} & {\color{yellow}11}
|
|
& {\color{yellow}28} & {\color{yellow}6}
|
|
& {\color{yellow}14} & {\color{yellow}5} & {\color{yellow}73}\cr}
|
|
\]
|
|
|
|
\begin{itemize}
|
|
\item On connaît la disponibilité totale de chaque fournisseur~: $a_i$.
|
|
\item On connait la demande totale de chaque client~: $b_j$.
|
|
\item $ \displaystyle { \sum_{origines} } \text{disponibilités des dépôts}
|
|
= { \sum_{client} } \text{demandes des clients}$
|
|
\end{itemize}
|
|
|
|
\subparagraph{Remarque} On peut toujours se ramener à ce cas, quitte à
|
|
créer une origine fictive ou un client fictif pour absorber la
|
|
différence entre
|
|
${\sum_{disponibilit\acute{e}}}$ et ${\sum_{demandes}}$.\\
|
|
|
|
On cherche un \emph{plan de transport}, soit une matrice $[X]$
|
|
$n\times m\rightarrow x_0=$ quantité transportée depuis $i$ vers $j$.\\
|
|
|
|
Matrice X 4/6 ?\\
|
|
|
|
Un plan de transport est valide s'il respecte certaines conditions~:
|
|
\begin{enumerate}
|
|
\item \textbf{contraintes de ligne~:} la quantité livrée par chaque
|
|
dépôt est égale exactement à la disponibilité.
|
|
$${\sum_n^{j=1}}x{ij} = a_{i}\qquad\forall{i}=1,2,\ldots,m$$
|
|
\item \textbf{contraintes de colonne~:} la quantité reçue par chaque
|
|
client est exactement égale à sa demande.
|
|
$${\sum_m^{i=1}}x_{ij} = b_{j}\qquad\forall{j}=1,2,\ldots,n$$
|
|
\end{enumerate}
|
|
|
|
Parmi tous les plans de transport $X=\left[x_{ij}\right]$ valides
|
|
(respectant toutes les contraintes), on cherche le plan de transport
|
|
de coût minimal.
|
|
|
|
Le coût d'un plan de transport donné est~:
|
|
$$z = {\sum_m^{i=1}\sum_n^{j=1}}x_{ij}C_{ij}$$
|
|
|
|
Évaluation de la difficulté du problème.
|
|
\begin{itemize}
|
|
\item Nombre d'inconnues~: $n\times m$, ici 24 inconnues, la matrice $X$~;
|
|
\item nombre d'équations imposées (contraintes)~: $n + m = 10$ équations~;
|
|
\item nombre d'équations indépendantes~: $n + m - 1$, ici $9$~;
|
|
$$\sum\text{disponnibilités des dépôts}=\sum\text{demandes des clients}$$
|
|
\end{itemize}
|
|
|
|
\paragraph{Définition} Un plan de transport est dit non dégénéré (ou
|
|
solution de base) si l'excès d'inconnues par nombre d'équations
|
|
indépendantes est nul.
|
|
|
|
On cherche un plan de transport ayant $n\times m - (m + m - 1)$
|
|
variables nulles (15 variables nulles, 9 variables non nulles).
|
|
|
|
Méthode de recherche du plan de transport de coût minimal (ou plan de
|
|
transport optimal) 2 phases~:
|
|
\begin{enumerate}
|
|
\item \textbf{Heuristique de la différence maximale (ou de Balas-Hammer)~:}
|
|
cette méthode fournie une solution de base de bonne qualité, de manière
|
|
constructive, servant de base pour la phase 2.
|
|
\item En partant du plan de transport procuré par la phase 1,
|
|
on cherche par itération successives le plan de transport optimal.
|
|
\end{enumerate}
|
|
|
|
\paragraph{Phase 1} On calcule pour chaque \emph{rangée} (ligne ou colonne) la
|
|
différence entre le coût unitaire le plus petit et le coût unitaire qui lui est
|
|
immédiatement supérieur.
|
|
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
|
|
\hline
|
|
& 1 & 2 & 3 & 4 & 5 & 6 & disponnibilité
|
|
& $\Delta_e$ lignes\\ %Ici : n = 4; m = 6
|
|
\hline
|
|
I & 12 & 27 & 61 & 49 & 83 & 35 & {\color{yellow}18} & {\color{orange}15}\\
|
|
\hline
|
|
II & 23 & 39 & 78 & 28 & 65 & 42 & {\color{yellow}32} & {\color{orange}5}\\
|
|
\hline
|
|
III & 67 & 56 & 92 & 24 & 53 & 54 & {\color{yellow}14} & {\color{orange}29}\\
|
|
\hline
|
|
IV & 71 & 43 & 91 & 67 & 40 & 49 & {\color{yellow}9} & {\color{orange}3}\\
|
|
\hline
|
|
demande & {\color{yellow}9} & {\color{yellow}11}
|
|
& {\color{yellow}28} & {\color{yellow}6} & {\color{yellow}14}
|
|
& {\color{yellow}5} & {\color{yellow}73} &\\
|
|
\hline
|
|
$\Delta_c$ & {\color{orange}11} & {\color{orange}12}
|
|
& {\color{orange}17} & {\color{orange}4} & {\color{orange}13}
|
|
& {\color{orange}7} & &\\
|
|
\hline
|
|
\end{tabular}
|
|
|
|
\begin{itemize}
|
|
\item On identifie la rangée (ligne ou colonne) correspondant à la
|
|
différence maximale (ici la ligne III).
|
|
\item On repère, dans cette rangée, la relation $(i,j)$ de coût
|
|
unitaire le plus faible (ici la relation (III, 4)).
|
|
\item On affecte à cette relation la quantité de marchandise la plus
|
|
élevée possible, c'est-à-dire, le minimum du couple
|
|
$\left(\text{disponibilité}, \text{demande}\right)$ associé à
|
|
cette case~: $\min(6, 16) = 6$.
|
|
\end{itemize}
|
|
|
|
Cette opération a pour effet de saturer une rangée (ici la colonne 4),
|
|
et on actualise la disponibilité ou la demande restante (ici la
|
|
disponibilité de III~: $14\rightarrow 8$). On a éliminé une rangée, et
|
|
cela a permis de fixer une variable $x_{ij}$~:
|
|
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|}
|
|
\hline
|
|
& 1 & 2 & 3 & 5 & 6 & disponibilité & $\Delta_e$ lignes\\ %Ici : n = 4; m = 6
|
|
\hline
|
|
I & 12 & 27 & 61 & 83 & 35 & {\color{yellow}18} & {\color{orange}15}\\
|
|
\hline
|
|
II & 23 & 39 & 78 & 65 & 42 & {\color{yellow}32} & {\color{orange}16}\\
|
|
\hline
|
|
III & 67 & 56 & 92 & 53 & 54 & {\color{yellow}8} & {\color{orange}1}\\
|
|
\hline
|
|
IV & 71 & 43 & 91 & 40 & 49 & {\color{yellow}9} & {\color{orange}3}\\
|
|
\hline
|
|
demande & {\color{yellow}9} & {\color{yellow}11} & {\color{yellow}28}
|
|
& {\color{yellow}14} & {\color{yellow}5} & {\color{yellow}67} &\\
|
|
\hline
|
|
$\Delta_c$ & {\color{orange}11} & {\color{orange}12}
|
|
& {\color{orange}17} & {\color{orange}13} & {\color{orange}7} & &\\
|
|
\hline
|
|
\end{tabular}
|
|
|
|
On itère le processus jusqu'à ce que tout le tableau soit barré~; à la
|
|
dernière itération (ici la huitième), deux variables sont affectées
|
|
d'un seul coup.
|
|
|
|
\subparagraph{Remarque} si deux différences maximales sont égales, on
|
|
a plusieurs solution. Ici, à la quatrième itération, on a deux
|
|
différences maximales égales à 13~: on choisira arbitrairement la
|
|
liaison $(IV, 5)$.
|
|
|
|
$z = 3535$ solution de base, de bonne qualité, mais pas optimale.\\
|
|
|
|
\paragraph{2\ieme{} phase} recherche de la solution optimale~: on construit le
|
|
graphe biparti associé à la solution de base précédente.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (I) {$I$};
|
|
\node[main node] (II)[right of=I] {$II$};
|
|
\node[main node] (III) [right of=II]{$III$};
|
|
\node[main node] (IV) [right of=III]{$IV$};
|
|
\node[main node] (6) [below left of=I] {$6$};
|
|
\node[main node] (1) [right of=6]{$1$};
|
|
\node[main node] (2) [right of=1]{$2$};
|
|
\node[main node] (3) [right of=2]{$3$};
|
|
\node[main node] (4) [right of=3]{$4$};
|
|
\node[main node] (5) [right of=4]{$5$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(I) edge [right] node[right] {42} (6)
|
|
(I) edge [right] node[right] {23} (1)
|
|
(I) edge [right] node[right] {39} (2)
|
|
(I) edge [right] node[right] {78} (3)
|
|
(II) edge [right] node[right] {61} (3)
|
|
(III) edge [right] node[right] {92} (3)
|
|
(III) edge [right] node[right] {24} (4)
|
|
(III) edge [right] node[right] {53} (5)
|
|
(IV) edge [right] node[right] {40} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
On value ce graphe avec les coût unitaires.
|
|
|
|
On affecte aux différents sommets un potentiel~:
|
|
\begin{itemize}
|
|
\item potentiel 0 à l'origine de l'arc de coût max, ici le sommet III~;
|
|
\item différence de potentiel arc $(i, j)$~: $v_j-v_i=C_{ij}$.
|
|
\end{itemize}
|
|
|
|
On calcule le coût marginal de chacune des liaisons $(i,j)$
|
|
inutilisées dans la solution de base~: $S_{ij}=v_i-v_j+c_{ij}$. On
|
|
cherche s'il existe une liaison inutilisée de coût marginal négatif.
|
|
$$S_{I,1} = 31 - 37 + 12 = 6$$
|
|
$$S_{I,2}=31-53+27=5$$
|
|
$$S_{III,6}=0-56+54=-2$$
|
|
|
|
Ici un seul coût marginal est inférieur à 0~; la solution analysée n'est pas
|
|
optimale. On utilise une chaine améliorante.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {$III$};
|
|
\node[main node] (2) [right of=1] {$6$};
|
|
\node[main node] (3) [right of=2] {$II$};
|
|
\node[main node] (4) [right of=3] {$3$};
|
|
\node[main node] (5) [right of=4] {$II$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(2) edge [->, right] node[right] {3} (1)
|
|
(3) edge [<-, right] node[right] {2} (2)
|
|
(4) edge [->, right] node[right] {10} (3)
|
|
(5) edge [<-, right] node[right] {0} (4)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
\[
|
|
X=\bordermatrix{~ & 1 & 2 & 3 & 4 & 5 & 6 & ~\cr
|
|
I & & & 18 & & & & {\color{yellow}18}\cr
|
|
II & 9 & 11 & {\color{red}10} & & & {\color{red}2} & {\color{yellow}32}\cr
|
|
III & & & {\color{red}0} & 6 & 5 & {\color{red}3} & {\color{yellow}14}\cr
|
|
IV & & & & & 9 &&{\color{yellow}9}\cr
|
|
~ & {\color{yellow}9} & {\color{yellow}11}
|
|
& {\color{yellow}28} & {\color{yellow}6}
|
|
& {\color{yellow}14} & {\color{yellow}5} & {\color{yellow}73}\cr}
|
|
\]
|
|
|
|
|
|
On cherche la quantité déplaçable la plus élevée possible. On augmente
|
|
d'une même quantité $\alpha$ tous les arcs à l'endroit et on diminue
|
|
de $\alpha$ tous les arcs à l'envers~:
|
|
$$\alpha = 3$$
|
|
Le coût de cette solution est de $z = 18 * 61 + 9 * 23 + \ldots$.
|
|
$$z=3235 + S_{III,6} * \alpha$$
|
|
$$z=3529$$
|
|
|
|
\subparagraph{2\ieme{} itération} On construit le graphe associé au
|
|
plan de transport amélioré.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (I) {$I$};
|
|
\node[main node] (II) [right of=I]{$II$};
|
|
\node[main node] (III) [right of=II]{$III$};
|
|
\node[main node] (IV) [right of=III]{$IV$};
|
|
\node[main node] (3) [below left of=I] {$3$};
|
|
\node[main node] (1) [right of=3]{$1$};
|
|
\node[main node] (2) [right of=1]{$2$};
|
|
\node[main node] (6) [right of=2]{$6$};
|
|
\node[main node] (4) [right of=6]{$4$};
|
|
\node[main node] (5) [right of=4]{$5$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(I) edge [right] node[right] {61} (3)
|
|
(II) edge [right] node[right] {78} (3)
|
|
(II) edge [right] node[right] {23} (1)
|
|
(II) edge [right] node[right] {39} (2)
|
|
(II) edge [right] node[right] {42} (6)
|
|
(III) edge [right] node[right] {54} (6)
|
|
(III) edge [right] node[right] {24} (4)
|
|
(III) edge [right] node[right] {53} (5)
|
|
(IV) edge [right] node[right] {40} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
$$S_{I,1}=17-23+12=6$$
|
|
$$S_{I,2}=17-39+27=5$$
|
|
|
|
Tous les $S_{ij}$ des liaisons inutilisées sont supérieur à 0, on
|
|
s'arrête car le plan de transport analysé est optimal.
|
|
|
|
\subparagraph{Remarque} S'il existe un $S_{ij}$ de liaison inutilisée qui
|
|
soit égal à 0, cela signifie qu'il existe une autre solution de même
|
|
coût.
|
|
|
|
\[
|
|
X=\bordermatrix{~ & 1 & 2 & 3 & 4 & 5 & 6 & ~\cr
|
|
I & & & 18 & & & & {\color{yellow}18}\cr
|
|
II & 9 & 11 & {\color{red}10} & & & {\color{red}2} & {\color{yellow}32}\cr
|
|
III & & & & 6 & 5 & {\color{red}3} & {\color{yellow}14}\cr
|
|
IV & & & & & 9 &&{\color{yellow}9}\cr
|
|
~ & {\color{yellow}9} & {\color{yellow}11}
|
|
& {\color{yellow}28} & {\color{yellow}6}
|
|
& {\color{yellow}14} & {\color{yellow}5} & {\color{yellow}73}\cr}
|
|
\]
|
|
|
|
%cours du 5/06 et du 11/06
|
|
\chapter{Problèmes de flot maximal}
|
|
|
|
Il existe 2 types d'applications~:
|
|
\begin{itemize}
|
|
\item type réseau (de communication, routier, fluvial)~: comment faire
|
|
passer les éléments pour acheminer le débit maximun tout en
|
|
respectant toutes les contraintes de capacité~?
|
|
\item type affectation, par exemple un graphe biparti.
|
|
\end{itemize}
|
|
|
|
\paragraph{Définition} Un \emph{réseau de transport} est un graphe
|
|
orienté sans boucle qui comporte une entrée (ou une source $s$) et une
|
|
sortie (ou puits $p$).\\
|
|
|
|
Chaque arc $u$ est doté d'une capacité $c(u)\geq 0$, représenté $[]$
|
|
|
|
On s'intéresse à une fonction, appelée le flot.\\
|
|
|
|
On associe à chaque arc une fonction $f(u)=\text{flux transitant dans
|
|
l'arc } u$. $flot=\text{flux}_\text{tous les arcs}$ $f(u)$~:
|
|
inconnue $c(u)$~: donnée. C'est ce que l'on appel un \emph{flot}.
|
|
|
|
Celui-ci doit respecter 2 types de contraintes~:
|
|
\begin{enumerate}
|
|
\item $\forall{u} : 0\leq f(u) \leq c(u)$
|
|
\item $\forall\text{ noeud }x$ dans le réseau, la loi de
|
|
Kirshoff est vérifiée. (si $f(u)=c(u)$, on dit que l'arc $u$ est saturé).
|
|
\end{enumerate}
|
|
|
|
$$\sum\text{flux entrants}=\sum\text{flux sortants}$$
|
|
|
|
Un flot est valide si et seulement si, il respecte les deux conditions
|
|
ci-dessous. exemple~: le flot nul.
|
|
|
|
\paragraph{Définition} une \emph{coupe} sépare la source du puits.
|
|
|
|
On appel $S$ l'ensemble de sommets incluant obligatoirement $s$ et excluant
|
|
obligatoirement $p$.
|
|
|
|
$\bar{S}$ est l'ensemble de sommets complémentaires.
|
|
|
|
$(S,\bar{S})$ est une coupe séparant la source du puits.\\
|
|
|
|
\paragraph{Propriété} $\forall$ coupe $(S, \bar{S})$ considérée, la valeur
|
|
du flot mesurée au niveau de cette coupe est la même~: c'est $val(f)$
|
|
|
|
\paragraph{Définition} La capacité d'une coupe se définit par~:
|
|
$$c(S,\bar{S}) = \sum{c(u)}_{arcs allant de S vers \bar{S}}$$
|
|
|
|
La valeur d'un flot ($val(f)$) se définit de 3 manières différentes~:
|
|
\begin{enumerate}
|
|
\item Valeur à la source (hypothèse~: pas de flux entrants dans $s$)
|
|
$$val(f)=\sum_{\text{arcs issus de }s}f(u)$$
|
|
\item Valeur au puits $p$ (pas de flux sortants de $p$)
|
|
$$val(f)=\sum_{\text{flux des arcs entrants dans }p}f(u)$$
|
|
\item Valeur au niveau d'une coupe $(S, \bar{S})$ quelconque.
|
|
$$val(f)=\sum_{\text{arcs allant de }S\text{ vers }\bar{S}}f(u)
|
|
\sum_{\text{arcs allant de }\bar{S}\text{ vers }S}f(u)$$
|
|
\end{enumerate}
|
|
|
|
\paragraph{Résultats théoriques}
|
|
\begin{enumerate}
|
|
\item $\forall$ coupe $(S,\bar{S})$ considérée, la valeur du flot mesurée au
|
|
niveau de cette coupe est la même~;
|
|
\item $\forall\text{ flot }f$ et $\forall\text{ coupe }(S, \bar{S})$, établi dans un réseau de
|
|
transport~: $Val(f)\leq c(S,\bar{S})$.\\
|
|
Si on trouve un flot $f$ et une coupe $(S,\bar{S})$ tels que~: $Val(f) =
|
|
c(S,\bar{S})$, alors le flot est de valeur maximale, c'est le flot optimal
|
|
\end{enumerate}
|
|
|
|
\section{Théorème du float maximal}
|
|
|
|
Le flot de valeur maximum est identique à la coupe de capacité minimale.
|
|
|
|
La coupe $(S,\bar{S})$ de capacité minimale respecte les propriétés suivantes~:
|
|
\begin{itemize}
|
|
\item Tout arc $u$ allant de $S$ vers $\bar{S}$ dont $f(u)=c(u)$ est dit saturé.
|
|
\item Tout arc $u$ allant de $\bar{S}$ vers $S$ est de flux nul ($f(u)=0$).
|
|
\end{itemize}
|
|
|
|
Lorsque le flot est maximal (et que la coupe de $(S,\bar{S})$ est de capacité
|
|
minimale)~: { Pour tout arc de $(S,\bar{S})$, il est saturé: $f(u)=c(u)$ { Pour
|
|
tout arc de $(\bar{S},S)$, il est de flux nul~: $f(u) = 0$
|
|
|
|
\section{Algorithme de Ford-Fulkerson}
|
|
|
|
Cet algorithme a pour but de déterminer le flot optimal dans un réseau de
|
|
transport donné.
|
|
|
|
\begin{itemize}
|
|
\item On part d'un flot initial établi dans le réseau (soit un flot établi à
|
|
la main, soit un flot nul)~;
|
|
\item on cherche s'il existe dans le réseau une \emph{chaîne augmentante}~
|
|
reliant $s$ à $p$~:
|
|
\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (1) {$s$};
|
|
\node[main node] (2) [right of=1] {};
|
|
\node[main node] (3) [right of=2] {};
|
|
\node[main node] (4) [right of=3] {};
|
|
\node[main node] (5) [right of=4] {$p$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(1) edge [->, right] node[right] {$[6]$ 2} (2)
|
|
(3) edge [->, right] node[right] {$[3]$ 3} (2)
|
|
(3) edge [->, right] node[right] {$[12]$ 5} (4)
|
|
(4) edge [->, right] node[right] {$[7]$ 1} (5)
|
|
;
|
|
\end{tikzpicture}
|
|
\item Cette chaîne est dite \emph{augmentante} si et seulement s'il existe un
|
|
nombre positif $\alpha$ que l'on peut ajouter au flux de tous les arcs à
|
|
l'endroit (sans aller au delà de leur saturation) et retrancher de tous les
|
|
arcs à l'envers (sans aller en-dessous du flux nul). Ici~:
|
|
$\alpha_{\max}=3$ et $\alpha_{\min}=\left(\min\left(c(u)-f(u)\right);\min
|
|
f(u)\text{ des arcs à l'envers}\right)$
|
|
\item Exploiter une chaine augmentante, c'est rechercher le $\alpha$ maximum.
|
|
$$\alpha = [Min(c(u)-f(u)); Min f(u)]$$
|
|
\end{itemize}
|
|
|
|
\subsection{Principe de l'algorithme de Ford-Fullkerson}
|
|
\begin{itemize}
|
|
\item On part d'un flot initial~;
|
|
\item On cherche s'il existe une chaîne augmentante reliant $s$ à $p$.\\
|
|
Si oui~: on exploite cette chaîne, on augmente $\alpha$ de la valeur du
|
|
flot et on recommence cette étape.\\
|
|
Si non~: on a atteint le flot optimal.
|
|
\end{itemize}
|
|
|
|
\subsection{Recherche d'une chaîne augmentante dans le réseau}
|
|
Procédure de marquage des sommets.
|
|
\begin{itemize}
|
|
\item marquer (on note $+$ à côté du sommet) l'entrée du réseau~;
|
|
\item \textbf{marquage en avant~:} marquer ($+I$ à côté du sommet $J$)
|
|
l'extrémité terminale $J$ de tout arc $(I,J)$ non saturé et dont
|
|
l'extrémité initiale est déjà marquée~;
|
|
\item \textbf{marquage en arrière~:} marquer ($-L$ à côté du sommet $J$)
|
|
l'extrémité initiale $K$ de tout arc $(K,L)$ de flux non nul dont
|
|
l'extrémité terminale $L$ est déjà marquée.
|
|
\end{itemize}
|
|
|
|
Ces deux phases de marquage avant et en arrière sont alternées jusqu'au blocage.
|
|
|
|
Si au moment du blocage, on constate que l'on a pu marqué $p$, cela signifie
|
|
que le flot considéré n'est pas encore optimal. On se sert alors des marques
|
|
pour identifier les différents sommets constituant la chaîne augmentante.
|
|
|
|
Si au moment du blocage, on constate que l'on a pas pu marqué $p$, dans ce cas
|
|
le flot considéré est optimal.
|
|
|
|
\paragraph{Remarque} Si l'on considère la dernière itération de marquage
|
|
réalisé (où l'on n'a pas pu marqué $p$), on a la coupe $(S,\bar{S})$ de
|
|
capacité minimale où $S$ est constitué de la liste des sommets marqués.
|
|
|
|
On véfifie que la valeur de cette capacité est égale à la valeur du flot
|
|
obtenu~: le flot maximal = la coupe de capacité minimale.
|
|
|
|
\paragraph{Remarque} Pour diminuer le nombre d'itération de l'algorithme de
|
|
Ford-Fullkerson, on s'efforce généralement de partir d'un \emph{flot initial
|
|
complet} (tout chemin de $s$ à $p$ comporte au moins un arc saturé).
|
|
|
|
\paragraph{Attention} Ne pas confondre les problèmes de flot optimal avec les
|
|
problèmes de plans de transport de coût minimal.
|
|
|
|
\section{Application (poly. p103)}
|
|
\begin{itemize}
|
|
\item 2 ports $A$ et $B$~: quantités 10 et 10~;
|
|
\item marchandises demandées dans 3 ports $C$, $D$ et $E$ selon les quantités
|
|
9, 12 et 7.
|
|
\end{itemize}
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (s) {$s$};
|
|
\node[main node] (A) [right of=s]{$A$};
|
|
\node[main node] (C) [right of=A]{$C$};
|
|
\node[main node] (D) [below right of=A]{$D$};
|
|
\node[main node] (B) [left of=D]{$B$};
|
|
\node[main node] (E) [below right of=B]{$C$};
|
|
\node[main node] (p) [right of=D]{$p$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(A) edge [right] node[right] {[7]} (C)
|
|
(A) edge [right] node[right] {[4]} (D)
|
|
(B) edge [right] node[right] {[5]} (C)
|
|
(B) edge [right] node[right] {[5]} (E)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
\begin{enumerate}
|
|
\item Peut-on satisfaire toutes les demandes~?\\
|
|
Non, car l'offre est inférieure à la demande~:\\
|
|
offre totale = $10+10=20$~; demande totale = $9+12+7=28$
|
|
\item Comment organiser les expéditions de façon à louer un maximun
|
|
de marchandise~?
|
|
\end{enumerate}
|
|
|
|
\begin{itemize}
|
|
\item transformer ce problème en un problème de recherche du flot maximal dans
|
|
un réseau de transport~;
|
|
\item résoudre par l'algo de Ford-Fulkerson~;
|
|
\item \textbf{initialisation~:} on s'efforce de démarrer l'algo à partir d'un
|
|
flot complet (tout chemin de $s$ à $p$ comporte au moins 1 arc saturé)~:
|
|
\begin{itemize}
|
|
\item flux 7 de $A$ vers $C$~;
|
|
\item flux 9 de $C$ vers $p$~;
|
|
\item Kirschoff au noeud $C$~: flux 2 de $B$ vers $C$ (OK car $<$ capacité
|
|
de 5)~;
|
|
\item flux 10 de $s$ vers $A$~;
|
|
\item Kirschoff en $A$~: flux 3 de $A$ vers $D$ (OK car $<$ capacité de
|
|
4)~;
|
|
\item Kirschoff en $D$~: flux 3 de $D$ vers $p$ (OK car $<$ capacité de
|
|
12)~;
|
|
\item on sature $B-E$~;
|
|
\item Kirschoff au n\oe ud $E$~: flux de 5 sur $E-p$ (OK car $<$ capacité
|
|
de 7)~;
|
|
\item Kirshchoff au noeud $B$~: flux de 7 sur $s-B$ (OK car $<$ capacité de
|
|
10).
|
|
\end{itemize}
|
|
\end{itemize}
|
|
|
|
On a un flot complet de valeur 17.
|
|
|
|
On a pu marquer $p$~: le flot considéré n'est pas optimal :
|
|
|
|
%faire un graphe avec ça : s ->[10](7) B ->[5](2) C <-[7](7) A ->[4](3) D ->[12](3) p
|
|
%devient 8, 3, 6, 4, 4
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (s) {$s$};
|
|
\node[main node] (A) [right of=s]{$A$};
|
|
\node[main node] (B) [right of=A]{$B$};
|
|
\node[main node] (C) [right of=B]{$C$};
|
|
\node[main node] (D) [right of=C]{$D$};
|
|
\node[main node] (p) [right of=D]{$p$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(s) edge [right] node[right] {[10] 8} (A)
|
|
(A) edge [right] node[right] {[5] 3} (B)
|
|
(B) edge [right] node[right] {[7] 6} (C)
|
|
(C) edge [<-, right] node[right] {[4] 4} (D)
|
|
(D) edge [right] node[right] {[12] 4} (p)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
Exploitation de la chaîne augmentante avec $\alpha$ : le flot passe de 17 à 18.
|
|
|
|
\begin{itemize}
|
|
\item Le nouveau flot est encore complet~;
|
|
\item le nouveau flot est de valeur 18 ($10 + 8$ ou $9 + 4 + 5$)~;
|
|
\end{itemize}
|
|
|
|
2\ieme itération~: on ne peut pas marquer $p$, donc le flot optimal est de
|
|
valeur 18.
|
|
|
|
La coupe où $S$ équivaut à l'ensemble des sommets marqués en dernière
|
|
itération.
|
|
|
|
La capacité de la coupe $(S,\bar{S})$ est~: $c(C,p) + c(A,D) + c(B,E) = [9] +
|
|
[4] + [5] = 18$
|
|
|
|
On a trouvé une coupe dont la capacité est alors à la valeur d'un flot.
|
|
|
|
C'est que le flot de valeur maximum et la coupe est de la capacité minimal.
|
|
|
|
\paragraph{Remarque} Tous les arcs de $(S,\bar{S})$ sont saturés (tous les
|
|
arcs de $(\bar{S},S)$ sont de flux nul)
|
|
|
|
%ici graphe et tableau exo
|
|
\begin{figure}[h]
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2.5cm,
|
|
thick,main node/.style={circle,fill=blue!20,draw,font=\sffamily\Large\bfseries}]
|
|
\node[main node] (A) {$A$};
|
|
\node[main node] (s) [below left of=A]{$s$};
|
|
\node[main node] (B) [below right of=s]{$B$};
|
|
\node[main node] (C) [below right of=A]{$C$};
|
|
\node[main node] (D) [right of=A]{$D$};
|
|
\node[main node] (E) [right of=B]{$C$};
|
|
\node[main node] (p) [right of=C]{$p$};
|
|
|
|
\path[every node/.style={font=\sffamily\small}]
|
|
(s) edge [right] node[right] {[10] 10} (A)
|
|
(s) edge [right] node[right] {[10] 8} (B)
|
|
(A) edge [right] node[right] {[7] 6} (C)
|
|
(A) edge [right] node[right] {[4] 4} (D)
|
|
(B) edge [right] node[right] {[5] 3} (C)
|
|
(B) edge [right] node[right] {[5] 5} (E)
|
|
(C) edge [right] node[right] {[9] 9} (p)
|
|
(D) edge [right] node[right] {[12] 4} (p)
|
|
(E) edge [right] node[right] {[5] 7} (p)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
|
|
Flot maximal de 4 (En partant du flot nul)
|