ngrenon/udem/cours/ift2121/notes de cours... · web viewcours ift2121 – introduction à...

Cours IFT2121 – Introduction à l'algorythmique

Cours 1, lundi 9 janvier 2006

Tp hebdomadaire individuels 35% (Reçu le jeudi, remis le vendredi suivant (8jours))Intra 1: 10%Intra 2: 15%Final: 40%

Livre: Brassard et Bratley Fundamentals of Algorythmics.

Bases:- Définir de quoi on parle- Prouver que ça marche- Évaluer la performance Apprendre à réfléchir M'assurer que c'est «bon».

Heuristique:Méthode pour solutionner un problème sans garantie de résultat.

On veut définir:AlgorythmeProblèmeComplexité (d'un algorythme ou d'un problème) (!= compliqué)

Algorythme:(essai 1) Suite d'opérations simples. (pour résoudre un problème).(essai 2) Une suite d'opérations «simples» qui se termine.

Problème:(essai 1) Données: Ensemble fini

But: Trouver une solution étant donné les données.nota: Un exemplaire (instance) d'un problème est un cas particulier de l'énoncé général d'un problème.

Devoir: - Lire chapître 1 (pas de remise)Notamment: Multiplication à la russe et PGCM (Euclide)

Nota: Chercher ds liste triée: log(n)Trier: (moy) n.log(n) | (pire) n2

Parlons Algorythme:Preuve que ça marche (…)Efficacité: (en terme de temps et/ou d'espace) [qui sont généralement inv. prop]

À posteriori (expérimentale)À priori Ce qui nous intéresse

Exemple: Trier un fichier de n éléments. Pourquoi peut-on dire n.log(n) ?

Pour représenter les données, la bonne mesure serait le nombre de bit (représentation binaire)Différentes représentations f1(d), f2(d), f3(d) vont prendre le même espace à une cte multiplicatrice près.

Principe d'invariance: Deux représentations des mêmes données ne diffèrent que par une constante multiplicative.

Efficacité: [ En moyenne | Au pire de cas | Au meilleur des cas (peu intéressant) ]Opération élémentaire: Instruction qui prend un temps constant.

Problème Algorythme Analyse en espace et en temps Complexité en espace et en tempsAprès avoir analysé différents algorythmes, on peut maintenant parler de la complexité du problème, qu'on peut

cerner en déterminant le pire et le meilleur.

Cours 2, jeudi 12 janvier 2006

Ordre des opérations:1. Problème (le plus difficile)2. Modèle (Suffisamment précis pour être programmé)3. Solution (même une preuve d'impossibilité)4. Algorythme "abstrait"5. Preuve de validité (autant que possible)6. "Analyse" (place, temps, …) [versus l'algo oui, mais aussi versus le problème]7. Algorythme (précis)8. Preuve, analyse 9. Structures des données10. Analyse11. Implémentation12. Test (etc.)

Optimal: On ne peut pas faire mieux!N'importe quel autre algo va au moins prnedre ce temps.

Pour déterminer l'optimalité, on doit pouvoir comparer les algorythmes. La taille d'un exemplaire d'un problème est mesurée le plus souvent pas le nombre des données clées. (Pour un graphe, le nombre de sommets, pour un fichier le nombre de lignes, etc.)

n données deront représentées par c∙f(n) bit

Pour calculer c∙f(n), on compte le nombre d'opérations élémentaires(opérations qui prennent au plus un certain temps constant)

Soit une application f:NR≥0

order O(f) = {g: NR≥0 | c Є R≥0 n0 Є N n ≥ n0 g(n)≤c∙f(n)}(qu'il existe une constante qui multipliée à la fonction f fera (à partir d'un certain point n0) que f sera

toujours supérieure à g)nous donne une borne supérieure

oméga (f) = {g: NR≥0 | d Є R≥0 n0 Є N n ≥ n0 g(n)≥d∙f(n)}theta (f) = O(f) (f)

Tri: n clés en O(n2) par Bablesortn clés en O(nlgn) par QuickSort (en moyenne)

Prouvons que n'importe quel algorythme qui tri par comparaison prendra au minimum nlgn.

Soit A, un algo qui tri par comparaison (inconnu).L'algo va prendre une première paire: a1 ?< b1et selon le résultat, il va suivre une seule branche jusqu'au bout.

Il y a n! façon de trier l'ensemble. Donc on aura n! branches à l'arbre. On cherche alors la hauteur de l'arbre.


O(f), (f) et (f) sont des ensembles dont f(n) est un élément. f(n) = O(f(n)) est donc une notation peu raisonnable.

Rappel: Les fonctions sont de N dans R≥0 dans le cadre de ce cours.

Propriétés des ordres et quelques outils.

1. O(f(n)) = O(g(n)) ssi f(n) Є O(g(n)) et g(n) Є O(f(n))Preuve:

Évidemment, si O(f(n)) = O(g(n)) alors f(n) Є O(g(n)) et g(n) Є O(f(n))Dans l'autre direction, supposons f(n) Є O(g(n)) et g(n) Є O(f(n)).

On prouve que si t(n) Є O(f(n)), alors t(n) Є O(g(n)) et que si t(n) Є O(g(n)) alors t(n) Є O(f(n))Si t(n) Є O(f(n)), on a alors qu'il existe un C Є R≥0 et n0 Є N tel que n≥n0 , t(n) ≤ c.f(n)On a également d > 0 n, Є N tel que n≥n, f(n)≤d.g(n).Donc t(n) ≤ c.f(n) ≤ c.d g(n) n ≥ max{n0, n1}.Avec la constante c.d on a alors que t(n) Є O(g(n)).De la même façon, mutitis mutandi, t(n) Є O(g(n) t(n) Є O(f(n)

2. Mutatis mutandis, la même observation pour et .

3. La règle du maximum :Soit f, g deux fonctions. Soit h(n) = f(n) + g(n).Soit q(n) = max {f(n), g(n)}On observe facilement que h(n) = q(n) + min {f(n), g(n)}.q(n) ≤ h(n) ≤ 2.q(n)On voudrait O(h(n)) = O(q(n)). Ce qui est vrai

On veut prouver que h(n) Є O(q(n)) et q(n) Є O(h(n)), mais on l'a déjà observé plus haut.Pour que la règle soit utile, on a quand même besoin d'une condiction supplémentaire:

Il faut qu'il existe un nm Є N tel que q(n) = f(n) pour n ≥ nm.

3'. Ceci se généralise à , k ≥ 2 et q(n)=max{fi(n) | i=1, …, k}

4.

Preuve:Par définition, on a: >0 n0 ЄN tel que |f(n)/g(n) –c| < Si f(n)/g(n) –c < 0, on a f(n) < c.g(n)Si f(n)/g(n) –c ≥ 0, on a f(n)/g(n) –c < , donc f(n)<(c+)g(n)Donc dans tous les cas, si n ≥ n0, f(n) < (c+)g(n), i.e.:

f(n) Є O(g(n)).Puisque lim f/g = c >0 lim g/f = 1/c, on a prouvé mutatis mutandis, que g(n) Є O(f(n))

5. , alors f(n) Є O(g(n)) et g(n) n'est pas dans O(f(n))

Preuve:Par définition, f/g < >0 et n≥n0

Donc, f(n) < .g(n), i.e.: f(n) Є O(g(n))Pour la deuxième partie, supposons que g(n) Є O(f(n)), i.e.: c > 0 n0 Є N tel que n ≥ n0 g(n) ≤ f(n).

Ceci implique que f/g ≥ 1/c, donc pour <1/c, on ne peut pas avoir f/g< pour n ≥ max{n0, n1}

6. , alors g(n) Є O(f(n)) et f(n) n'est pas dans O(g(n)).

Preuve:

ssi , ce qu'on a prouvé au cas précédent.

Ordres conditionnels:

, par exemple, nous cause problème pour trouver l'ordre dans une récurrence …

Soit P, une propriété des naturels. (Qui peu être V ou F, ou on peut dire qu'elle forme un sous-ensemble des N)

Notons O(f(n)|P(n)) l'ensemble { t:NR≥0 | c Є R≥0 , n0 Є N ( n≥n0 et P(n) ) t(n) ≤ c.f(n) }

ex.: { t:NR≥0 | c > 0 , n0 , n ≥ n0 , k > 0, n = 3k t(n) ≤ c.n3 }

Définitions:1. Une fonction f est éventuellement non-décroissante si n0 Є N tel que n ≥ n0 f(n) ≤ f(n+1)2. Soit b ≥ z, b Є N. On appelle une fonction f b-lisse si elle est é.n.d

et si f(bn) ≤ c.f(n) pour une constante c > 0 etn ≥ n0, pour n0.3. Une fonction est lisse si elle est b-lisse pour tout b ≥ 2, b Є N.

Remarques:a) Si t est é.n.d. alors m > n ≥ n0, f(n) ≤ f(m)b) f est b-lisse veut dire que f(bn)/f(n) ≤ c.

Théorème:Soit f:NR, une fonction b-lisse pour 2≤bЄN, alors f est lisse.

Preuve:Soit b≥2, cb>0, n0 Є N tel que f(bn) ≤cb.f(n) pour n ≥ n0.On veut: aЄN, a≥2, ca et na tel que f(an) ≤ ca.f(n), si n≥na

Soit a Є N, a ≥ 2. On a .On a également, pour tout k Є N, f(bkn) ≤ cb

kf(n).

Donc

Donc en prenant na = max{n0, n1} et ca = cb[logba], on a ce qu'on cherche.

Si on met n1 égale au seuile de la définition é.n.d. de la définition.


Théorème:

Soit f:+ lisse et soit t: + é.n.d. Soit b ≥ 2.Si t(n) O(f(n)) | k , n=bk) alors t(n) O(f(n))

Preuve:On a: n1 | f(n) ≤ f(n+1) pour n ≥ n1

On a: d c n2 | f(dn) ≤ cf(n) pour n ≥ n2

En particulier: f1(bn) ≤ cbf(n) pour n ≥ n2

n3 t(n) ≤ t(n+1) pour n ≥ n3

On a: a n4 | t(n) ≤ af(n) pour n ≥ n4 et n = bk

Soit n0 = max {n1, n2, n3}

Si on prend acb comme la constante, on a que t(n) ≤ acbf(n) pour tout n ≥ n0

Exemples:

1. f(n) = 2n3 + n2 – lgn g(n) = 106n3 + 3n

, donc O(f(n)) = O(g(n))

2. f(n) = 2n3 + n2 g(n) = n2 + lgn

, donc g(n) O(f(n)), mais f(n) O(g(n))

4. f(n) = lg n g(n) = lg lg n = lg (lg n)

, donc g(n) O(f(n)), mais f(n) O(g(n))

* aurait été plus facile avec une substitution de variable, par exemple x = lgn

5. f(n) = an2 + bn + c a, b, c + g(n) = n2

On prétend que f(n) O(n2 | n = 3k) f(n) O(n2)

f(n) ≤ f(n+1) ok.g(n) est lisse

On a que g(2n) 4n2 = 4g(n) ok.

Opérations sur les ordres: (Définitions)

O(f) + O(g) = O( f(n) + g(n) )Soit X et Y deux ensembles de fonctions de vers + Soit ° une opération binaire sur les fonctions.On défini X ° Y = { t:≥0 | f X, g Y, no tel que pour n≥n0, t(n) = f(n) ° g(n) }Quand X (ou Y) ne contient qu'une fonction, on abuse de la notation en écrivant: f ° Y si X = { f }

Ex.: nO(1)

O(f) O(g):

Démo 2, vendredi 20 janvier 2006

Notons: O est Réflexive, Transitive, Non-symétrique.

Ex.: Montrer que log(n!)=(nlogn)

log(n!) O(nlogn)log(n!) = log(1,2,3…, n) = (1..n) logn = n logn, avec c=1, n=1

donc log(n!) O(nlgn)log(n!) (nlgn)

log(n!) lgi = lg1 + lg2 + … + lgn

Cas n pair et n impair (…)(bla)

lg(n!) (nlgn), avec n=4, c=1/4

Devoir 1:#1: ok#2: ok#3: plus simple en faisant la limite de lim f/g=lim 2n2n/2n=lim 2n

Utile à noter: lg(n!) ≥ ¼nlgn, n≥4

Ex.:f(n)=(log(n!n) + nn^2) log(n!) ) (n3(logn)2)

Prenons n! ≤ nn

On a: n!n ≤ (nn)n = nn^2

n!n + nn^2 ≤ 2 nn^2

log(n!n + nn^2) ≤ lg2 + lg nn^2 = 1 + n2lgn≤ 2n2lgn n ≥2

etc.

Ex.:Montrer que lgn O(n)

, ce qui implique: lg(n) O(n)

Ex.:Donner l'ordre des fonctions par O: nlgn nlogn nn 2n (ils sont en ordre maintenant)

, ce qui implique: O(nlgn) O(nlgn)

, car lgn - n < 0, ce qui implique: O(nlgn) O(nn)

, car lnn - nln2 < 0

Ex.:a, b ≥ 0 Montrer que (n+a)b = (nb)

, cqfd

Ex.:Ordonner par O: O(1/n) O(lgn) O(n) O(n2) O(lgnlgn) O((n)lgn O(2lgn^2) O(2n!) O(2n!)


n=O(1) = {t(n): ≤0 | t(n)=ng(n), g(n) O(1) = {t(n) | f {h(n) | g(n) O(1) n0 t.q. t(n) = f(n)g(n) }

O(1) = {g(n) | c > 0 n0 n>n0 g(n) ≤ c}

nO(1) = ?

t(n) = ng(n) ≤ nc ≤

Soit t(h) ≤ p(n) où p(n) est un polynôme , ak > 0

Alors t(n) nO(1) car p(n) ≤ cnk+1 pour n≥n0

nO(1) = {t(n) | , ak > 0 n0 n≥n0 t(n) ≤ p(n) }

Rappel: f(n) (g(n)) ssi c,d + n0 t.q. n≥n0 cg(n) ≤ f(n) ≤ dg(n)

Exemple trivial pour la suite: (Recherche dichotomique?) [nota: tn == t(n)]

t(1) = 0 (ou 1 si pas là, pas important puisque constant)

Si on suppose que n=2k, ceci devient facile:

t(1) = 0

t(n) = tn/2 + 1 = tn/4 + 2 = … =

On a donc t(n) = lgn

t(n) (lgn | n=2k )Mais lgn est é.n.d. et lg2n = 1+lgn ≤ 2lgn (n≥2), donc lgn est lisse. En plus, t(n) est énd:

tn ≤

Donc le théorème nous dit que t(n) (lg n)

Récurrence:

t0 = do

t1 = d1

tk = dk

tn = fonciton de t0, …, tn-1 Ex.: tn = 3tn-2 – 2tn-1 0 = -tn + 3tn-2 – 2tn-1 0 = tn – 3tn-2 + 2tn-1

Cette récurrence est linéaire et homogène.

On cherche une fonction tn = t(n) qui vérifie R.

Exemple de tantôt: n = 2k

tn = tn"2 + 1t(n) = lg n Mais comment on y arrive?

Avec un peu d'expérience (une centaine d'essais):

Supposons que t(n) = xn

Alors on obtient , l'équation caractéristique de R. De cette équation on tire son polynome caractéristique:

. Notons que .

On voit que soit x=0, soit ssi i.e.: p(x)=0 .

Donc pour trouver une solution à R, il suffit d'en trouver une à p(x)=0.

On observe que si fn et gn sont des solutions de R, alors cfn + dgn en est une pour tout c, d .

Soit fn, gn t.q. et .

Soit c, d des constantes. Alors

Moral (par induction): Une combinaison linéaire de solutions en est une également.

Soit R une récurrence et soit p(x) son polynôme caractéristique qui est de deré k. Par la théorème fondamental d'algèbre, p(x) possède exactement k racines (dans , pas forcément distincts). Soit r1, …, rk ces racines. Par notre propositions, des solutions à R sont r1

n, r2n, …, rk

n et donc on a, par l'observation précédente, une solution générale (c1 … des cte):

c1r1n + c2r2

n + … + ckrkn =

Si les racines sont distincts (ri != rj si i!=j) alors il ny a pas d'autres solutions.

Exemple:

pour n ≥ 2 R: tn – 5tn-1 + 6tn-2 = 0p(x) = x2 – 5x + 6

Posons: p(x)=0. Alors on trouve (x-2)(x-3)=p(x). Mes racines sont donc 2 et 3.

On constate que la solution générale est c12n + c23n

Mais, c120 + c230 = 0 et c121 + c231 = 1, donc c2 = 1 et c1 = -1

Donc tn = -2n + 3n !

Vérifions: -2n + 3n = 5(-2n-1 + 3n-1) – 6(-2n-2 + 3n-2)= -32n-1 – 2n + 23n-1 + 32n-2 - 23n-1

= … (ok, bien sûr)

Recette:1. Récurrence obtenue de l'analyse

2. On en fait

3. On trouve le polynôme caractéristique p(x)4. On trouve les racines r1, …, rk de p(x)

5. Si elles sont distinctes, alors

6. On trouve les ci à partir du système d'équation linéaires obtenueà partir des conditions initiales.

Exercice lire: Chap3, 4…


Sur les récurrences…

, pourvu que ri rj si ij

Que se passe-t-il si on a des racines multiples?

Supposons que p(r)=0 et r est une racine de multiplicité m, i.e. p(x)=(x-r)mq(x) où

On a que: p(r)=0En plus: p'(x) = m(x-r)m-1q(x) + (x-r)mq'(x) (on dérive m-1 fois)

p'(r)=0p(i)(r)=0, pour i=1, …, m-1

Fixons n: Soit

On sait que u1(r)=0, car u1(x)=xn-kp(x)et u1'(r)=0, car u1'(x)=(u-k)xn-k-1p(x)+xn-kp'(x) (on obtient donc plusieurs solutions)

Je peux créer des vj en dérivant u et multipliant par x …

On obtient: et vj(x)=0 pour j=1, …, m-1.

On en conclu que tn = nrn, n2rn, n3rn, …, nm-1rn sont des solutions à R !

Soit et p(x) son polynôme caractéristique. Soit r une racine de multiplicité m. On a donc rn, nrn,

n2rn, …, nm-1rn comme solution de R et donc on a que . Supposons que les racines de p(x) sont

r1, …, rl, avec les multiplicités respectives m1, …, ml . La solution générale de R est:

Exemple:

R: tn – 8tn-1 + 25tn-2 - 38tn-3 + 28tn-m – 8tn-5

p(x) = x5 – 8x4 + 25x3 – 38x2 + 28x – 8

on essaie 0, marche pas… on essaie 1, ok:

p(1)=0 p(x)= (x-1)(x4-7x3+18x2-20x+8= (x-1)2(x3-6x2+12x-8)= (x-1)2(x-2)3

Donc on a: l=2, r1=1, r2=2, m1=2, m3=3

tn = c101n + c11n1n + c202n + c21n2n + c22n22n = c10 + c11n + c202n + c21n2n + c22n22n

0 = c10 + c20

1 = c10 + c11 + c202 + c212 + c2222 = c10 + c112 + c204 + c218 + c22163 = c10 + c113 + c208 + c2124 + c22724 = c10 + c114 + c2016 + c2164 + c22256

Démo 3, vendredi 27 janvier 2006

1a:i:=n;tant que i ≥ 1 fairedébut

pour j=1 à n fairex:=x+1

i:=

finexécution 1: i=n

2: i=…

k: i= =1

O:

1 ≤ n/2k < 2 2k ≤ n < 2k+1

k ≤ lg(n) < k+1 k =

f(n) O(lgn) ≤ lg(n)

+1 ≤ lg(n) + 1 ≤ 2lg(n) n ≥ 2.

f(n) ≤ 2nlg(n) n ≥ 2.c=2, n0=2.f(n)O(nlgn)

:f(n)(nlgn)

+1 ≥ lgn

n( +1) ≥ nlgnf(n) (nlgn)

1b:i:=2tant que i < n fairedébut

i:=i2x:=x+1

fin

exécution 1: i = 22: i = 22 = 43: i = 164: i = (22)3

…k: i = (22)k-1

(22)k-1 < n ≤ (22)k

(2)k-1 < lgn ≤ (2)k

k-1 < lglgn ≤ k

f(n) = k = (lglgn)

≥ lglgnf(n) (lglgn)

≤ lglgn + 1

≤ 2lglgnf(n) O(lglgn) n≥4

donc f(n) (lglgn)

2: Montrer que (n-1) + (n) = (n)

f(n) (n-1) + (n)f(n) = f1(n) + f2(n) tel que f1(n) (n-1) et f2 (n)f1(n) O(n-1) et f2(n) O(n)c1>0, n1≥0,n≥n1 f1(n) ≤ c1(n-1)c2>0, n2≥0,n≥n2 f2(n) ≤ c2(n)f(n) = f1(n) + f2(n) ≤ c1(n-1) + c2(n) = (c1 + c2)n – c1

≤ (c1 + c2)nc3 = c1 + c2

f(n) O(n)

c4>0, n4≥0,n≥n4 f4(n) ≤ c4(n-1)c5>0, n5≥0,n≥n5 f5(n) ≤ c5nf(n) ≥ c4(n-1) + c5n = (c4 + c5)n – c4

≥ (c4 + c5)n – c4n n≥1f(n) (n)

ou plus simplement:f(n) ≥ f1(n)f(n) (f2(n)) (n)f(n) (n)

donc f(n) (n)

f(n) = f(n)/2 + f(n)/2On montre que: f(n)/2 (n-1) et f(n)/2 (n).On a f(n) (n) f(n)/2 (n) (par définition)

f(n) O(n) on montre que f(n)/2 O(n-1)c1>0, n1≥0,n≥n1 f(n) ≤ c1nf(n)/2 ≤ c1n/2 ≤ c1n/2-(-c1n+3c1/2) -(-c1n+3c1/2) ≥ 0

-c1n+3c1/2 ≤ 0-c1n ≤ -3c1/2n ≥ 3/2

On a f(n)/2 ≤ 3c1n/2 – 3c1/2 = (3c1/2)(n-1)c = 3c1/2, nmax(3/2, n1)

f(n)/2 O(n-1)

f(n) (n) on montre que f(n)/2 (n-1)c2>0, n2≥0,n≥n2 f(n) ≥ c2nf(n)/2 ≥ c2n/2 ≥ c2/2 = c2/2(n-1)c=c2/2 , n=n2

f(n)/2 (n-1)

DONC: (n-1) + (n) = (n)

On n'a pas: (n) - (n-1) = (n)Contre-exemple:

f1(n) = n (n)f2(n) n-1 (n-1)

f1(n) - f2(n) = 1 (n)

4: Résoudre la récurrence suivante: fn+3 = 7fn+2 – 15fn+1 + 9fn f0=0, f1=1, f2=2

p(x) = x3 – 7x2 + 15x – 9 = 0p(x) = (x-1)(x2-6x+9) = (x-1)(x-3)2 = 0

x=1, x=3(double)

fn = c1(1)n + c2(3)n + c3n3n = c1 + c23n + c3n3n

f0 = c1 + c2 + 0 = 0 c1 = -c2

f1 = c1 + 3c2 + 3c3 = 1 (2)f2 = c1 + 9c2 + 18c3 = 2 (3)

(3) – 4x (2) 6c3 = -2 c3 = -1/3 c2=1 c1=-1

fn = -1 + 3n - n1/33n

fn = 3n – n3n-1 – 1

3: , n puissance de 2.

n T(n)1 12 31+222 3(31+2) + 22

23 3(32 + 32 + 22) + 23 = 33 + 322 + 322 + 23

T(2k) = 3k20 + 3k-121 + 3k-222

+ … + 302k =

n = 2k

k = lgn

T(n) = 3lgn+1-2gn+1 = 3lgn3-22lgn = 3nlog3 - 2nT(n) (nlg3 \ n puissance de 2)

T(n)est non décroissante (par induction)

nlg3 lisse

2-lisse f(2n) O(f(n))car: (2n)lg3 = 2lg3nlgn O(nlg3)et nlg3 est non décroissante cat lg3>1

donc, d'après le théorème du cours, on peut donc conclure:

T(n) (nlg3) (sans condition)


Soit où pj(n) est un polynôme en n de degré dj.

Alors le polynôme caactéristique devient:

et (donc), la solution générale est: (pas utile de s'en souvenir par coeur)

(Lecture 4.7, 4.8, 4.9)

Exemples:

1- tn = -3tn-1 = 2n

équivalent à: tn-1 – 3tn-2 = 2n-1

on les soustrait: tn – 5tn-1 + 6tn-2 = 0

x2 – 5x + 6 = 0 (x-2)(x-3)

tn = c12n + c23n

Testons…: c1 = 1, c2 = 0tn = 2n

2n - 32n-1 = 2n oups! (on a perdu de l'information)

Testons la solution générale: c12n + c23n – 3(c12n-1 + c23n-1) = 2n

c12n + c23n - 3c12n-1 – c23n = 2n1c12n – (2+1)c12n-1 = 2n

-c12n-1 = 2n c1 = -2 (même sans conditions initiales!)

tn = c23n – 2n+1 , donc tn (3n) si c2 > 0Soit t0 la valeur initiale, on t0 = c2 – 2 c2 = t0 + 2

2- tn – 3tn-1 = (n+2)2n

On veut encore une fois se débarasser de la droite.

On sait que: tn-1 – 3tn-2 = (n+1)2n-1 , pas suffisant pour obtenir une constante multiplicative pour annuler la dPrenons aussi: tn-2 – 3tn-3 = n2n-2

On veut: (n+2)2n + c(n+1)2n-1 + dn2n-2 = 0

4(n+2)2n-2 + 2c(n+1)2n-2 + dn2n-2 = 04n + 8 + 2cn + 2c + dn = 0(4+2c+d)n + 8 + 2c = 0

4+2c+d = 08+2c = 0c = -4 , d = 4 on obtient donc notre récurrence homogène.

tn – 7tn-1 + 16tn-2 – 12tn-3 = 0

p(x) = x3 – 7x2 + 16x – 12 = 0 trouvons les racines…

p(x) = (x-3)(x2 – 4x + 4) = (x-3)(x-2)2

tn = c13n + c22n + c3n2n

Nota: p(x) de tn – 3tn-1 = 0 est de forme (x-b)di+1, avec b=2 et di = 1.

Testons la solution dans la récurrence de départ:

c13n + c22n + c32n – 3(c13n-1 + c22n-1 + c3(n-1)2n-1) = (n+2)2n

c13n + c22n + c3n2n – c13n – c232n-1 – c33(n-1)2n-1 = n2n + 2n+1

c22n + c3n2n – c232n-1 – c3n2n-1 + c332n-1 – n2n – 2n+1 = 0…c2 = -10, c3 = -2 tn = c13n + 102n -2n2n (avec c1 > 0, n'importe quoi puisqu'il disparaît) tn (3n)

3- tn = 5tn/2 + 3n pour n=2k, et n>1.

On voudrait: T(i) = t2î = 5t2^(i-1) + 3i = 5T(i-1) + 32i

T(i) – 5T(i-1) = 32i

p(x) = (x-5)(x-2) p(x) = p(x)(x-b)l+1

où q est un polynôme en n de degré d, sp(x) est le polynome

caractéristique de . Alors le polynôme caractéristique de R devient

p(x)(x-b)d+1. Nota: p = ^p

T(i) = c15i + c22i

Donc tn = c15lgn + c2n

Testons si ça fonctionne:

3n + 5tn/2 = c15lgn + c2n3n + 5(c15lg(n/2) + c2(n/2) = c15lgn + c2n3n + c155lgn-1 + 5c2(n/2) = c15lgn + c2n(3-c2)n + 5c2(n/2) = 0n(3-c2+(5/2)c2) = 03 = c2(1 - 5/2)c2 = - 2

tn = c15lgn – 2n donc c1 > 0 et en fait, on a besoin que c15lgn-2n > 0c1 > 2n/5lgn

c1 > 2 (approx.)

4- T(n) = nT3(n/3) n = 3i

On a: t(i) = i + 3t(i-1) (en prenant le log en base 3)

En détail: On met n = 3i

t(3i) = 3t3(3i-1)u(i) = log3t(i)u(i) = i + 3u(i-1)4(i) – 3u(i-1) = i donc b=1, p(x)=i

(x-3)(x-1)2

u2(i) = c13i + c21i + c3i1i = c13i + c2 + c3ii + 3(c13i-1 + c2 + c3(i-1)) = c13i + c2 c3ic3 = -1/2 et c2 = -3/4

u(i) = c13i – ¾ - 1/2it(i) = 3u(i) = 3c13Î – ¾ -1/2I = 3c13Î 3-3/4 3-i/2

T(n) = 3c1n 33/4 3-log3(n)/2 = 3c1n 1/33/4n t0 > 0

Cours 8, jeudi 2 février 2006

Récurrences particulières du type:

Dans une récurrence, on a souvent des valeurs initiales, donc on peut prendre n ≥ n0

Supposons que n/n0 = bi , i.e.: n = n0bi i=logb(n/n0)

Explication par exemple:

Soit: s=logbaAlors: rs=vlogb(a) = alogb(r)

logbrlogba = logbalogbr

Donc:

Prenons: ,

On considère les possibilités de la relations entre l et bk :

1) 1 > l/bk [i.e.: c4 > 0] bk > l k > logblAlors: pour n ≥ n1

Donc: T(n)(nk | n=bk)et on en tire que T(n)(nk) n, car nk est lisse et T(n) est é.n.d.

2) 1 < l/bk [i.e.: c4 < 0] bk < l k < logblmême raisonnementDonc: T(n)(nlogb(l) | n=bk) ... n

3) l=bk (dans le polynôme caractéristique, on a maintenant des racines multiples: (x-l)(x-bk)=(x-l)2 )t(i) = c5li + c6lii = c5bki + c6bkiI rappel: (n/n0

k) = bik

= c5(n/n0)k + c6(n/n0)ki= c7nk + c8nklogb(n/n0) = lT(n/b) + cnk

c7nk + c8nklog(n/n0) = bk[c7(n/b)k + c8(n/b)klogb(n/bn0) + cnk]c8logb(n/n0) = c8log(n/bn0) + c = c8logb(n/n0) – c8 + cc8 = c > 0 T(n) (nk logb(n/n0)) (nklogn)

Démo 4, vendredi 3 février 2006

Ex1: Résoudre: T(n) = 2T(n/2) + n2 montrant que T(n) (n2)

Posons n = 2k

T(n) = 2(2T(n/4) + n2/22) + n2

= 22T(n/22) + n2/2 + n2

= 22(T(n/23)+n2/24) + n2/2 + n2

= 23T(n/23)+n2/22+n2/2+n2

= 2kT(n/2k) + n2/2k-1 + ... + n2/20

= nT(1) + n2(2-2/2k)= nT(1) + 2n2 – 2n= 2n2 + n(T(1) -2)

Donc: T(n) (n2 | n puissance de 2)

Comme: n2 est énd. f(n)=n2 f(bn)=b2n2 ≤ b2f(n), avec c=b2 Ok!T(n) énd se montre par induction:

base: T(2) = 2T(1) + 4 ≥ T(1) okhypothèse: i < n T(i) ≥ T(i-1)Montrons que: T(n+1) ≥ T(n)

T(n+1) = 2T((n+1)/2) + (n+1)2

= 2T(n/2 + ½) + (n+1)2

On a: T(n) = 2T(n/2) + n2

T(n/2 + ½) ≥ T(n/2)T(n+1) ≥ 2T(n/2) + (n+1)2

≥ 2T(n/2) + n2 = T(n)cqfd (T(n) est bel et bien énd) Ok!

Donc: T(n) (n2)

Devoir: Ok, #2 à la fin, pas pour tous les cas!, il faut démontrer lisse et énd.

Ex2:

Polynôme caractéistique: (x2 – 3x + 2)(x-2)1 = 0 p(n)bn

(x-1)(x-2)2 = 0

x=1, x=2 (mult 2)

tn = c1 + c22n + c3n2n t0 = 1 t1 = 2 t2 = 3t1 – 2t0 + 3 = 7

etc. c1 = 3 c2 = -2 c3 = 3/2

tn = 3 - 22n + (3/2)n2n = 3n2n-1 – 2n+1 3

tn (n2n)

Ex3: Résoudre:

Changement de variable: (pas besoin de supposition)

Donc on a:

tk = 2tk-1 + 2k

p(x) = (x-2)(x-2)1 = (x-2)2 = 0 ( avec p(x)=p(n)bk )r1 = 2 (mult 2)

tk = c12k + kc22k = c12k + c2k2k t0 = c1 = T(2) = 1 t1 = 2c1 + 2c2 = T(4) = 2T(2) + 2 = 4 c2 = 1

tk = 2k + k2k

T(n) = lgn + lglgnlgn T(n) (lglgnlgn)

Ex4: Résoudre:

On réexprime:

Posons tn = T2(n)

avec p(n)bk

(x2 – x/2 – ½)(x-1)2 = 0(x+1/2)(x-1)(x-1)2 = 0 x = -1/2 et x = 1 (mult 3)

tn = c1(-1/2)n + c2(1)n + nc3(1)n + n2c4(1)n

On a: t0 = 0 t1 = 1 t2 = T2(2) = 1/2T2(1) + 1/2T2(0) + 2 = 5/2 t3 = ... = 19/4

On va obtenir: c1 = -2/27 c2 = 2/27 c3 = 5/9 c4 = 1/3

tn = n2/3 + 5n/9 + 2/27(1-(-1/2)n)

T(n) (n)

Ex5: (4.42)

à essayer en exercice.

Cours 9, lundi 6 février 2006

Résumé:

1)

Si les racines de p(x) sont r, r2, ..., rl, de multiplicité m1, ...,ml

2) où q(n) est de degré d, b≥1

Polynôme caractéristique:

3) où qi(n) de degré d

Polynôme caractéristique:

4)

Regardons des récurrences approximatives, de forme: où

Exemple: Soit

Prenons a,b ≥0 :

on va essayer de limiter T(n) entre deux extrèmes ...

On obtient (dans le devoir):

Ce qui veut dire:

On conclu que: (é.n.d. et lisse)

On cherche u, v, r, s ≥0 tels que Tr,s(n) ≤ T(n) ≤ Tu,v(n)

On sait qu'il existe n0, c, d ≥0 tels que cn ≤ f(n) ≤ dn pour n≥n0. Donc

(n ≥ n0)

Considérons , i.e.

On observe que Ta,a = aT1,1(n). Ceci découle par induction par n=1, on a Ta,a(1)=a=a1=aT1,1(1)

Pour n>1 .

Notons également que pour 0 < a ≤ x, 0 < b ≤ y , on a Ta,b(n) ≤ Tx,y(n) n(induction encore)

Choisissons nos u, v, r, s:

Tr,s(n) ≤ Tr,r(n) = rT1,1(n) ≤ T(n) ≤ uT1,1(n) = Tu,u(n) ≤ Tu,v(n)

Graphes: non-orienté: G = (V, E)orienté: D = (V, A)

Sous-graphes H de G est H = (U, F) tel que U V,

Sous-graphe induit:

Chemin: x1, ..., xn, ..., xi V, xixi+1E

G est connexe si u, v V x0, ..., xk V tel que x0=u1,xk=v et x0, ..., xk est un chemin.

Convention pour les graphes (sauf cas contraire): n = |V(G)| (nœuds) m = |E(G)| = a (arrêtes)

Donnée: G = (V, E)Question: Est-ce que G est connexe?Réponse: DFS ou BFS (Depth first search ou Breadth first search)

recherche jusqu'au bout de chaque branche /

Rappel: La complexité-temps d'un problème est le nombre d'opérations élémentaires de algorithme le plus rapide.

«claim»: comp(DFS) (m)

?comp(DFS) (max{n,m})

Rappel: G peut-être représenté par

1) Matrice d'adjacence. MVxV où l'entrée

2) Liste d'adjacence: Soit v1(u), ..., vd(u)(n) les voisins du sommet u. Alors la liste pour u est v1(u), ..., vd(u)(n) et la liste pour G: u1: v1(u1), ..., vd(u1)(n)

un: vn(un), ..., vd(un)(n)

Donc, on voit que la complexité dépend de la représentation ...


Algorithmes gloutons (vorace, "greedy"):

Données «configuration» qui «optimise» certaines valeurs.

Souvent: sujet à des conditions.

Soit D=(V;A) un graphe orienté.Soit w:A>0 une fonction de poids. (On donne un poids à chaque arrête)On dit que D est pondéré par w.En général, on peut écrire D=(V;A;w) avec w:A où w:V et on peut généraiser davantage.

Questions types: 1- Le coût d'un parcours visitant tous les sommets. (Glouton = pas bon)2- Arbre de coût minimum. (ACM ou MST en anglais) (Glouton = ok)3- Le plus court chemin. (Glouton = ok)

Soit G=(V;E) un graphe pondéré par w:E.

Un arbre couvrant minimum (sous-tendant) de G est un sous-graphe T=(V;F) qui est un arbre tel que soit

minimum, i.e. T'=(V,F'), arbre couvrant de G, w(T)≤w(T').

[voir notes de cours pour le théorème]

Ordre de l'algorithme (Prim): Trivial: O(n2)par monceau: ? (Monceau = Heap)


Lire 5.7 et 5.9!

ACM:

Kruskal

n sommets, m arêtes

Temps: au minimum m (voir tts arêtes)où? liste triée? mlgmn-1 (liste des arêtes)union 2 ensembles = ?

union/find ~6m

Donc: O(mlgm)O(nlgn) si mO(n)O(n2lgn) si m(n2)

Prim

On regarde la liste des sommets liés à notre arbre déjà construit. On étiquette les nœuds à chauqe sommet puis on cherche le minimum. Donc n pour l'étiquetage et n pour la recherche.

Temps: O(n2)

Kruskal sera donc préférable s'il y a peu d'arêtes et Prim s'il y en a plusieurs.

Union/find: Structures d'ensembles disjoints.

Données: Un ensemble X = {1, ..., n}

But: Étant donnée une partition c1 c2 ... ci de X, on veut1) fusionner ci et cj étant donnée i,j.2) trouver i tel que x Ci pour x donné.

Si on choisi le côté le moins haut pour faire l'ajout, on reste en O(logn).

Tarjan: O(2m((f+t),2m)) qui augmente très lentement (voir le livre)

nota: Dans ces deux algo, il n'y a pas de problème à avoir des poids négatifs.

Plus court chemin:

Données: Les plus courts cheminsBut: Trouver les distances et des chemins les plus courts de x vers tous les autres sommets.


Ensembles disjoints:

Ex.1: Regrouper n objets numérotés de 1 à n dans des ensembles disjoints. Chaque objet est dans un seul ensemble. (p.179)

(1), (2), (3), (4), ..., (11)

Initialement, chaque ensemble contient un seul objet.

Les opérations à utiliser: - Find(x) : Permet de chercher et de trouver l'ensemble qui contient l'élément x.- Fusionner(a, b): Permet de grouper les deux ensembles a, b.

L'objectif est de trouver la façon la plus efficace de faire les opérations précédentes.

ité1: (1), (2), (3), (4), ..., (11)ité2: (1,3), (2), (4), ..., (11)ité3: (1,3,5), ...ité i: A(1,3,4,7), B(2,5,6,9), C(8,10,11)

On caractérise chaque ensemble par son plus petit élément.

A:1, B:2, C:8

Tableaux:

Soit un tableau qui contient les ensemble auxquels chaque élément appartient.

ité1: [1,2,3,4,5,6,7,8,9,10,11]ité2: [1,2,1,4,5,6,7,8,9,10,11]ité i: [1,2,1,1,2,2,1,8,2,8,8]

Fonction Find(x) O(1)retourner Set[x] (la classe qui représente x)

Fonction Fusionner(a,b) O(n)i min(a,b)j max(a,b)pour k 1 à n faire

Si Set[k] = j, alors Set[k] = i

Donc: Fusionner(1,2) ité i+1: [1,1,1,1,1,1,1,8,1,8,8] (deux ensembles!)

Ce traitement se fait, au pire es cas, en O(n2).O(n) pour fusionnern-1 fusions au maximumFind(x) se fait quant-à lui en O(1)

Arbres:

On représente chaque ensemble par un arbre, où chaque noeud contient un pointeur vers son parent.Soit Set[i]=i, alors i est le représentant de l'ensemble (c'est la racine de l'arbre).

Si Set[i]=j i , alors j est le parent de i.

Ex.:[1,2,3,1,2,4,3,2,2,1,3]

Fonction Find2(x)r xtant que Set[r]r faire

r Set[r]retourner r

Fonction Fusionner2(a,b)Si a < b alors

Set[b] aSinon

Set[a] b

Ce traitement se fait toujours en O(n2)Find2 est en (n)n-1 fusions ...

Arbre, suite:

On considèe un tableau des hauteurs [1...n] contenant la hauteur des arbres contenant chaque élément.Hauteur[i] donne la hauteur du noeud i dans son arbre courant.

Ex.: [0,0,1,1,1,1,1,0,1,1,1]

Fusionner3(a,b)Si Hauteur[a] = Hauteur[b] alors

Hauteur[a] Hauteur[a] + 1Set[b] a

SinonSi Hauteur[a] > Hauteur[b] alors

Set[b] aSinon

Set[a] b

De cette façon, on a n fois Find2, chacun en O(logn). Au pire des cas on a donc O(nlogn).

Preuve:Base: k=1 0 ≤ log(1) ok.Hypothèse: i ≤ m < kDétail: L'arbre qui contient k noeuds peut s'obtenir en fusonnant deux arbres, un arbre

contient a nœuds, l'autre contient b nœuds et a+b = k. (a<h,b<h)Si ha hb

hk = max(ha, hb) ≤ max(loga, logb) (par l'hypothèse)≤ logh

Sinonalors: hk = ha + 1 ≤ log(a)+1 ≤ log(k)

Algorithme glouton:

Principe: Faire le choix qui semble être le meilleur à un moment de l'algorithme.

Ex1: Comment retourner la monnaie dans un magasin?Le client doit 2,57$ et il vous donne un bilet de 5$.Comment retourner la monnaie avec aussi peu de pièces que possible. (1¢, 5¢, 10¢, 25¢, 1$, 2$)

Stratégie gloutonne: À chaque moment, je sélectionne la plus grande pièce possible.

Solution:Ici, on doit retourne 2,43$Donc: 2$ + 25¢ + 10¢ + 5¢ + 1¢ + 1¢ + 1¢

Fonction Change(n)const c = {2$, 1$, 25¢, 10¢, 5¢, 1¢}S 0s 0while sn faire

x la plus grande valeur dans c telle que s+x ≤ nSi ceci n'existe pas, retourner «pas de solution»S s {la pièce de valeur x}s s+x

retourner S

Mais ne retourne pas toujours de solution...Par exemple, pièces={5,2} et n=6

Retourne (1,0) qui n'est pas une solution réalisable.

N'est pas optimal non plus...Par exemple, pièces={5,4,1} et n=8

Retourner (1,0,3) au lieu de (0,2,0).

Conclusion: L'algorithme glouton ne trouve pas toujours une solution optimale ou réalisable.

Exemple 2 (Graphes + algo glouton):

Kruskal:

Étapes Arête considérée Composantes connexes0 - {0}, {1}, {2}, {3}, ...1 {1,2} {0}, {1,2}, ...2 {5,6} {0}, {1,2,5,6}, ...3 {0,6} {0,1,2,5,6}, ...4 {2,6} {0,1,2,5,6}, ...5 {6,7} {0,1,2,5,6,7}, ...6 {3,4} {0,1,2,3,4,5,6,7} , ...7 {3,5} {0,1,2,3,4,5,6,7}

Prim:

Choix de 0 comme départ: Arbitraire.

Étapes Arête ajoutée1 {0,6}2 {6,5}3 {6,2}4 {2,1}5 {1,7}6 {5,3}7 {3,4}


Algorthmes gloutons – suite:

Les plus courts chemins d'un sommet donné:

Donné: D=(V, A), pondéré par w:A≥0 un sommet u.But: Trouver les distances d eu vers tous les autres sommets. Ainsi que les plus courts chemins.

Théorème: L'algo de Dijkstra marche.

Preuve: On prouve par récurrence qu'après la i-ème itération, l(i) = d(u,j) si j Sl(j) = ds(u,j) si j S

où ds(u,j) est la longueur d'un plus ocurt chemin de u vers j qui ne contient que des sommets de S, à l'exception de j.

À l'itération 0, S={u},l(j) = si j S et j N+(u) (avec N+ le voisinage: {j|(u,j) A})et l(j) = w(u, j) si j N+(u)

On suppose que c'est vrai pour les itérations 0, 1, ..., i-1. Regardons pour l'itération i: ok.

On prouve d'abord que li(k)=l(l)=ds(u,k)=d(u,k):On montre que si P est un chemin de u vers k, alors P est au moins aussi long que le chemin par S de vers k dont la longueur est donnée par l(k). Soit P est un chemin de u vers k. Si P

ne contient que des sommets de S (sauf k), alors |P|≥l(k) par l'hypothèse d récurrence. Si P passe par des sommets qui ne sont pas dans S, soit x le premier tel sommet sur le chemin P=u-v1-v2-x. Par le choix de k, l(x)≥l(k), donc |P|≥l(x)≥l(k). D'où l(k)=d(u,k).

Soit tV\S. Si (k,t)A, li(t)=li-1(t) est donnée ds(u,t) car les chemins par S de u à t ne passent pas par k. Si tN+(k), alors ds(u,t)=min{li-1(t), li(k)+w(k,t)} car on arrive à t soit via k, soit pas, mais

c'est exactement la nouvelle étiquette li(t).

Nota: On conserve une paire d'information à chaque point: L'étiquette l(k) ET le parent par lequel on est arrivé.

Analyse: Naïvement: n itérations avec n-i vérifications à chaque fois. O(n2)Par monceau d'étiquettes: n (pour le monceau)

mises-à-jour: nombre d'arête.Total: (mlgn)(Si D est connexe)

Sac-à-dos:

Données: n objets 1, ..., n, l'objet i de valeur vi et de poids wi et W le poids maximum.

But: où xi [0,1]

s.à:

Observation: - La condition devient quand .

- La mesure utile est vi / wi .

D'où l'algorithme: On prend les dci tel que vi / wi est maximum parmi les objets restants, jusqu'à ce qu'on arrive à W.

Théorème: L'algorithme simple est bon.

Preuve: Soit X=(x1, ..., xn), où on suppose que les vi / wi sont triés pour que , i=1, ..., n-1.

On a que X est une solution si . Donc soit . Si xi = 1

i=1,...,n, la solution est optimale.

Supposons que X est uen solution de l'algorithme glouton.

On note que dans ce cas, si xi1 i, il existe un plus petit j{1,...,n} tel que xi=1 si i<jxi=0 si i>jxj[0,1) sinon

Soit Y=(y1, ..., yn) une solution optimale. On va calculer V(Y)-V(X)

Ici, on a que pour i<j: yi – xi ≤ 0i>j: yi – xi ≥ 0i=j: yi – xi = ?, mais ratio égal

Donc, dans tous les cas.

On conclut que X est optimale.


6.6.2: Ordonencement des tâches avec gains et temps limite.

Données: Un ensemble T de n tâches, {t1, ..., tn} T avec pour i {1, ..., n}, un gain gi ≥0 et un temps limite d.[Suppositions: Chaque ti prend une unité de temps.]

But: Trouver J T et une suite tel que soit le maximum réalisable. (sur tous les J T)

Sujet à dij ≤ j , pour j=1, ..., |J|.

Un ensemble J et une suite sont réalisable si dij ≤ j pour j=1, ..., |J|.

Exemple: t: 1 2 3 4 5 6 # tâched: 3 1 5 2 3 2 date limiteg: 20 30 10 5 20 50 gain associé

On va faire (intuitif):On place le plus payant possible en première positionOn essai le suivant.

Si on n'a pas le temps, on va regarder si on peut avant un précédenten ayant encore le temps pour le précédent)

On répète.

Ce qui donne: temps: 1 2 3 4 5 6tâche: 2 6 5 3 J = {2,6,5,3} (2,6,5,3)d: 1 2 3 5

Au pire: (n2) (à chaque (n) élément on peut parcourir/déplacer n élément)

Lemme: Soit J T un ensemble de tâches, J={t1, ..., tn}, tel que di ≤ di+1 pour i=1, ..., n-1. Alors J est réalisable ssi la suite l'est. (Une seule suite suffit.)

Preuve: suiteRéalisableJréalisableOn a que la suite est réalisable, alors J l'est. (simple)

JRéalisable suiteRéalisable

Si n'est pas réalisable, alors il existe un r tel que tr ne peut pas être accompli. Mais

les tâches t1, ..., tr-1 doivent être fini avant la tâche r, donc les r tâches t1, ..., tr doivent toutes être terminées dans les r-1 moments, ce qui est impossible. Donc J n'est pas

réalisable. (Preuve par la négation du contraire.)

Lemme: L'algorithme glouton marche. (Livre algo 6.6.3 du livre)

Preuve: Soit I, l'ensemble choisi par l'algo glouton.Soit J, un ensemble optimal.Soit SI , SJ les suites horaires des deux solutions respectivements.

Dans SI et SJ, les tâches comunes sont soit vis-à-vis, soit pas. Si elles ne le sont pas, soit il y a un trou vis-à-vis, soit pas. S'il y a un trou, on peut déplacer la tâche vis-a-vis, Sinon on peut

échanger la tâche qui bloque si je suis dans l'ensemble le plus avancé dans l'horaire. On peut donc produire un SI' et un SJ' dont les tâches comunes sont vis-à-vis.

Il ne peut pas rester un trou vis-à-vis une tâche restante puisque glouton ou optimal aurait ajouté le vis-à-vis.

Si deux tâches différentes, alors obligatoirement la même valeur. (sinon glouton ou optimal...)

Lemme 6.6.4 à lire...


Ex1: Algorithme Dijkstra

Entrée: Graphe orienté connexeG(N,A) |N|=n |A|=mLongueur L:ASommet origine = s

Sortie: Plus courts chemins (PCC)

P: (u1, u2, ..., un)

L[i,j] ≥ 0 si l'arc (i,j) existe. L[i,j] = + sinon.Les longueurs des arcs sont supposées positives.

fonction Dijkstra(L[1..n,1..n])L tableau[2..n]{initialisation}C {2,3, ..., n} {S = N \ C}Pour i=2 jusqu'à n faire

D[i] L[1,i]

Répéter n-2 foisu l'élément de C qui minimise D(v)C C, {v} {et implicitement SS {v}Pour chaque élément w et c faire

D[w] min(D[w], D[v] + L[v,w])

Retourner D

C S D{1,2,3,4,5,6,7} {0} [10, , , , , , 6]{1,2,3,4,5,6} {0,7} [9, , , , , 9, 6]{1,2,3,4,5} {0,7,6} [9, 13, , , 10, 9, 6]{2,3,4,5} {0,7,6,} [9, 10, , , 10, 9, 6] 2 choix apres: 2 et 5{3,4,5} {0,7,6,1,2} [9, 10, 15, , 10, 9, 6]{3,4} {0,7,6,1,2,5} [9, 10, 14, , 10, 9, 6]{4} {0,7,6,1,2,5,3} [9, 10, 14, 23, 10, 9, 6]

Ex.2: Sac à dos

On a n objets de poids w1, w2, ..., wn respectivement et de valeurs v1, v2, ... vn. La capacité maximale du sac est M.

But: Examiner x1, x2, ..., xn tel que en maximisant la valeur .

(Pour aujourd'hui on pose que 0 ≤ xi ≤ 1)

Sélection:- Prendre l'objet de plus grande valeur- Prendre l'objet de ps petit poids.- Prendre l'objet qui minimise vi / wi Optimale

La solution gloutone avec la sélection vi / wi est optimale.

Preuve:Sans perte de généralité, supposons que: v1/w1 ≥ v2/w2 ≥ ... ≥ vn/wn

Soit (x1, x2, ..., xn) une solution gloutone.

Il existe un entier j tel que xi=1 pour i < j xj = 0 pour i > j (j le plus petit indice tel que xj < 1).

et

Considérons n'importe quelle solution: y1, y2, ..., yn telle que: .

i < j:

On a: xi = 1 etyi ≤ 1 (xi – yi) ≥ 0de plus, vi/wi ≥ vj/wj (xi – yi)vi/wi ≥ (xi-yi)vj/wj

j > i:

On a: xi = 0 et yi ≥ 0(xi – yi) ≤ 0de plus, vi/wi ≤ vj/wj

(xi – yj)vi/wi ≥ (xi – yj)vj/wj

i = j:

On a: (xi – yj)vi/wi = (xi – yi)vj/wj

donc

donc: cqfd

Cet algorithme n'est pas optimal dans le cas xi = 1

Ex.: Max: 6x1 + 2x2 + 2x3

5x1 + 2x2 + 3x3 ≤ 4xi binares.

6/5 ≥ 2/2 ≥ 2/3j=0 x1=x2=x3=0 V(x)=0

Ex.3: Minimisation de l'attente.

Un serveur doit servir n clients. Chaque client i prendra un temps t i (t1...tn). Nous allons minimiser

Ex.: ti=5, 10, 3Solution: 1 2 3: 5 + (5+10) + (5+10+3) = 38

1 3 2: 5 + (5+3) + (5+3+10) = 312 1 3: ...3 1 2: 3 + (3+5) + (3+5+10) = 29 optimale3 2 1: ...

Mais on a n! solutions à vérifier!!!

Sélection: Choisir le client qui a le plus petit temps de service et qui n'est pas encore choisi.

Cet algorithme donne toujours un ordonnencement optimal.

Preuve:Soit I = (i1, i2, …, in) la solution trouvée par l'algorithme.

T(I) = ti1 + ti2 + ... =

Soit I' une autre solution telle que il existe deux indices a et b tel que:a < b et tia > tib

I = i1 i2 i3 ... ia ib … in [on a une inversion … un échange]I' = i1 i2 i3 ... ib ia … in

Preuve:

T(I) – T(I') = (n-a+1)(tia – tib) + (n-b+1)(tib – tia) = (b-a)(tia – tib) > 0

Ex.4: Ordonnencement avec échéances.

Soit un ensemble de 4 tâches. À chaque instant, t=1,2,3,4 on peut exécuter une et une seule tâche.La tâche i nous apporte un gain gi > o ssi elle est exécutée au plus tard à l'instant di.

ti = 1 i

i 1 2 3 4gi 50 10 15 30di 2 1 2 1

Séquences possibles Profit1 502 103 1 80 optimaleetc. ...

L'algorithme glouton construit l'ensemble des tâches à exécuter pas à pas en ajoutant la tâche non encore considérée ayant la plus grande valeur de gi si possible.

On choisit la tâche de plus grand profit, soit 1.Ensuite on choisi la tâche 4 et on vérifie si {1,4} est réalisable. (Ceci est dans l'ordre 4,1 on peut

exécuter les deux tâches sans dépasser le tmeps limite.)On choisit 3, mais {1,4,3} n'est jamais réalisable.

Si on choisi 2, ... n'est jamais réalisable.

Cours 14, lundi 6 mars 2006

Diviser pour régner: (divide et impera)

Ex.:Recherche (fouille) dichotomique (binaire).

g(n) (nk)

Ex.:QuickSort

< p = p > p

Pire cas: O(n2) (Quand on choisit systématiquement le pivot comme un extrême)En moyenne: O(nlogn)

Preuve: (sur le site web)

Définition: Soit T un ensemble de n clés. Soit T = {c1, ..., cn}, la suite des clés de T triées, i.e. ci ≤ ci+1 pour i=1...n-1Le sième

plus petit élément de T est cs.

La médiane de T est .

Supposons que l'on sache trouver rapidement. Alors on peut trouver cs rapidement pour tout s {1, ..., n}.

On va essayer de trouver une pseudo-médiane en prenant l'ensemble des médianes de sections d'une longueur

déterminée du lot de départ et en en trouvant la médiane. (Chaque section a une longueur de .

Supposons que l'on divise T en morceaux de 5 clés chaque. Supposons que l'on trouve la médiane de

chaque intervalle de taille 5 obtenu plus haut. Soit Z le tableau contenant les médianes. Supposons que p est la

médiane de Z. Dans chaque bloc bi de 5 clés, la médiane mi est trouvée en temps constant et on a que le nombre de

clés plus petit ou égale à m i est 3. Donc dans T, le nombre de clés ≤ p est . Mais , ce qui donne

que le nombre de clés ≥ p est au moins . Donc il y a au plus clés strictement plus

grandes que p. Mutadis mutandis, il y a au plus clés strictement plus petites que p.

On conclut que le temps requis pour trouver le s ième plus petit élément en utilisant la pseudo-médiane prend

.

On prétend que t(n)(n).Il est clair que t(n)(n), car chaque clé doit être vue.Pour l'autre direction, on procède par «induction constructive».

Supposons que t(n)≤cn pour une constante c et un n0.

D'abord, il est facile de trouver un c tel que t(n) ≤ cn si 1≤n≤n0 : il suffit de prendre le plus petit c tel que

.

Supposons que l'on ait ceci et que pour tout m < n, t(m) ≤ cm.On veut:

Il nous suffit donc que c/10 – d + 6c/5 ≥ 0 .

I.E.: (1-12/n)c ≥ 10d c ≥ 10d(1-12/n)

Mais comme n > n0 c ≥ 10d/(1-12/n0+1)

On obtient, par exemple: n0 = 12 c ≥ 130dn0 = 23 c ≥ 11d

Et de là on peut remonter la chaîne des ssi...

Cours 15, jeudi 9 mars 2006

Multiplicaon de matrices:

A, B deux matrices n x n sur . Notés aij et bij ou i colonne et j rangée. C le résultat de la multiplication:

Il faut donc calculr n2 valeurs cij, chacune prenant n multiplication. Donc on est dans (n3) !

On peut faire mieux (Strassen).

On observe qu'on peut multiplier deux matrices 2x2 en 7 multiplications, plutôt que 8. (Voir le livre)

Et comme on sait que pour de grosses matrices on peut les subdiviser pour en arriver à des matrices 2x2 (si n=2k).On obtient que m(n)=7m(n/2)+g(n) où g(n)(n2) m(n)(nlg7 | n=2k) (On remplira par des 0 au besoin)

Multiplication d'entiers:

a, b de taille k. ai, b, i {0,...,9}, i=0, ..., k-1

Supposons k pair.

(On résume les sommations par: a=x+w et b=z+y

ab = xz + 10k/2+1(xy+wz) + 10k+2wy

Soit r = (w + x)(y + z)q = xzp = wy

ab = 10k+2p + 10k/2+1(r-p-q) + q

Donc pour k = 2e, on a:

t(k) = 3t(k/2) + g(k) où g(k) (k) por les additions

t(k) (klg3 | k=2e)

Lire début du chapître 7 et les exemples: 7.1-7.4

Démo 7, vendredi 10 mars 2006

Ex.:7.12: A, un tableau trié de n éléments ditincts. On veut un algorithme pour trouver i tel que T[i]=i en temps O(logn) au pire cas.

On va employer un algo du type dichotimique. (...bla bla...)

trouver(T[p..q])i plancher((q-p)/2)Si A[i]=i, alors retourner iSi A[i]>i, alors retourner trouver(A[p..q-plancher(n/2))Sinon, retourner trouver(A[p+plancher(n/2)+1...n,q) (plus ou moins)

Multiplication des grands nombres:

mult(u,v)n plusgrandelongueur(u,v)Si n est petit, multiplication normale.s n div 2w u div 10s

x u mod 10s

y v div 10s

z v mod 10s

retourner(mult(w,y)102s + (mult(w,z) + mult(x,y))10s + mult(x,y))

Mais comme wz+xy = (w+x)(y+z)-wy-xz, on peut ne faire qu'une multiplication!

Multiplication de matrices:

Voir page 242.

Ex.7.13: L'utilisation d'une sentinelle dans merge pour le tri par fusion.

Pour éviter un overflow si on a des éléments 'infini'

fusion(u(1..n), v(1..n), T[1..n+m])u[n+1] v[m+1] i j 1for k 1 à n+m faire

Si u[i] < v[j] alorsT[k] u[i]i i + 1

SinonT[k] v[j]j j + 1

fusion(u(1..n), v(1..n), T[1..n+m])i j 1Tant que i≤n et j≤m faire

Si u[i] < v[j] alorsT[k] u[i]i i + 1

SinonT[k] v[j]j j + 1

Si j≤n alorsPour l=i à n faire

T[k] u[l]k k + 1

SinonPour l=i à m faire

T[k] v[l]k k + 1

Ex.7.17:

pivotbis(A[1,...,j],p) sections 7.4.2 et 7.5

(3)141592653(3)131592651(3)1312956542131(3)95654

pivotbis(A[i..j],p)k i-1l j+1Tant que k < l faire

Répéter k k+1 jusqu'à A[k]≥pRépéter l l-1 jusqu'à A[k]≤pSi A[k]=p alors

r kRépéter rr+1 jusqu'à A[r]<pÉchanger A[k] et A[r]Si A[l] < A[r+1] faire

Échanger A[r+1] A[l]Échanger A[r] et A[r+1]

Sinon l l+1Sinon

Échanger A[k] et A[l]Retourner l.

3141592653134159265313315926541133592654113329565411323956541123395654

Select:

Trouver le kième plus petit élément d'unsuite A(1..n) select(A[1..n), k)Si k = 1, on trouve le min. i j 1Si k = n, on trouve le max. Répéter

l pivotbis(A[i..j], p)Si l<k alors i l+1Si l>k alors j l-1

jusqu'à l=kRetourner A[l]

Exemple: Le 3e plus petit élément de 5325659834

2334555689 l=52334 l=2 plus ou moins sûr ^334 l=3 stop (l=k), retourner A[l], 3.


Voir feuillet sur le web sur les transformées de Fourrier Rapide.

... Dans le tableau, on met la représentation inversée de la position en binaire...


Cours 18,vendredi 17 mars 2006

Programmation dynamique (post Intra#2):

Problème: On remarque que pour calculer C(n,k), on a besoin d'environ 3n multiplications.

Version récursive (triangle de Pascal): C(n,k): / 0: Si n=0 ou k>n| 1: Si k=0 ou k=n\ C(n-1,k-1)+C(n-1,k): Sinon

En calculant dans un seul array (sur place) la ligne du bas d'un triangle de Pascal, on n'a besoin que de 1+2+3+... additions si on calcule tout le triangle. Et on n'a besoin que de faire les premières cases du tableau pour trouver à la position k!

Exemple2: Série mondiale.

Données: - 2 équipes A et B qui jouent un nombre impair de matchs (pas de nuls).- le premier à gagner n matchs gagne la série.- la probabilité que A gagne un match est p. (Donc que B gagne est q=p-1).

But: Calculer la probabilité que A gagne la série.

Soit p(i,j) la probabilité que A gagne la série si il lui faut i victoires et s'il faut j victoires à B.On cherche P(n,n). (i = n – victoires...)

On observe que P(i,j) = pP(i-1,j) + (1-p)P(i,j-1). (ordre exponentiel!)

On va se faire une matrice de j colonnes et i rangées de 0 à n. P(n,n) est en bas à droite...

i\j 0 1 2 ... n0 X 1 1 1 11 02 0... 0n 0 ?

Observons les diagonales, en particulier la sième.On peut les remplir une par une plus simplement. Ds = { M[i,j] | i+j=s } (ordre ponynomial, n2)

Principe d'optimaité:

Si je prends un problème p et si je peux obtenir la solution optimale en calculant des sous-problèmes p1 à pk, alors si on a une solution optimale à p les solutions de p1 à pk sont optimales.

Problème des chemins:

On remplit une matrice des distances entre les points.Solution simple (Dijkstra à chaque Pour la remplir, on a donc besoin de n2 opérations)

Prenons: G(V,E,c) c:E≥0 V={1,...,n}

Soit dk(i,j) la longueur d'un chemin le plus court de i à j dont les sommets internes (i.e.: les sommets dans lesquels on entre et desquels on sort) sont dans [1,...,k}.

Donc d0(i,j) = c(i,j). On obtient la récurrence dk(i,j) = min{ dk-1(i,j), dk-1(i,k) + dk-1(k,j) }. Nota: dn(i,j) = d(i,j)

Ex.:

itér. 0 1 2 3 4 51-2 1 1 1 1 etc.1-3 5 5 4 41-4 3 31-5 52-3 3 3 3 32-4 2 2 2 22-5 43-4 1 1 1 13-5 1 1 1 14-5 2 2 2 2

Donc on remplira la matrice correspondante n X n en (n3)

Floyd:

Warshall: Fermeture transitive d'un graphe (orienté ou pas). {on travaille avec des 1 ou des 0 uniquement ici}[On ajoute les arêtes à un graph qui peuvent être résumées par des chemins composés.][On peut aussi le comprendre ocmme l'action de compléter une matrice d'adjacence]

Multiplication chaînée de matrices:

On veut minimiser le nombre de multiplications. (Sinon beaucoup de répétitions.)

Le nombre n de «bon parenthèsages» (pour regrouper les les matrices par paires) et donnée par le nombre de Catalan.

(Notons qu'il est "bon" s'il y a toujours plus de parenthèses ouvertes que fermées...)

#bon = #total - #mauvais (évident)#total = C(2n,n)#mauvais = #parenthèsage avec n-1 parenthèse gauche et n+1 parenthèse droite.

Démo 8, lundi 20 mars 2006

Diviser pour règner:

1- Diviser le problème entier en sous-problèmes similaires.2- Régner: résoudre les sous-problèmes récursivement et combiner les solutions pour trouver la solution complète.

Exemple: La tranformée de Fourrier

n = 2k (n=8, et k=3)

a=[2,3,5,4,1,3,6,4]

[2,5,1,6] [3,4,3,4][2,1] [5,6] [3,3] [4,4][2] [1] [5] [6] [3] [3] [4] [4]

On obtient:

[2] [1] [5] [6] [3] [3] [4] [4] (ne changent pas!)

Pour F[2,1], on a: n=2 et n/2=1 t=0 donc b0=c0+w0d0 = 2+1 = 3.b0 + 1 = c0 – w0d0 = 2-1 = 1

Pour F[5,6], on b0 = c0 + w0d0 = 5+6 = 11b1 = c0 – w0d0 = 5-6 = -1

Pour F[3,3] = [6,0]Pour F[4,4] = [8,0]

Ligne suivante:

Pour F[2,5,1,6]: On a F[2,1] = [3,1] et F[5,6]=[11,-1]t=0,1b0=c0+w0d0=3+11=14b1=c1+w1d1=1-e2ipi/4=1-(cos(pi/2) + isin(pi/2))b2=b0+2=c0-w0d0=3-11=-8b3=b1+2=c1-w1d1=1+e2ipi/4=1+i [14,1-I,-8,1+i]

Pour F[3,4,3,4] = [14,0,-2,0]

Ligne suivante:

Pour F[2,3,5,4,1,3,6,4]:n=8, n/2=4mes b sont ma ligne dans la fonctionmes c sont les groupes utilisés à la ligne d'avantmes d sont les résultats de mes c transformés

t=0,1,2,3b0 = c0 + w0d0 = 14+14 = 28b1 = c1 + w1d1 = 1-i + 0 = i-ib2 = c2 + w2d2 = -8 -2(e2ipi/8)2 = -8 -2ib3 = c3 + w3d3 = 1+ib4 = b0 + 4 = c0 – w0d0 = 14-14 = 0b5 = b1 + 4 = 1-i - 0w1 = 1-ib6 = b2 + 4 = c2 – w2d2 = -8 +2ib7 = b3 + 4 = c3 – w3d3 = 1+i –w30 = 1+i

On a donc au pire des cas n opérations, la complexité est donc de nlogn

Programmation dynamique:

Plus longue sous-séquence commune:

Déf.: Soit x=(x1,...,xm) et z=(z1,...,zk) deux séquences.z est une sous-séquence de x si il existe des indices i,j tels que 1≤i1<i2<...<ik≤m tel que xij=zj j=1...k

z est une sous-séquence commune de x et y si z est sous-séquence de x et y.z est la plus longue sous-séquence de x et y si aucune sous-séquence de x et y est plus longue que z.

nota: ne se suivent pas forcément!!

Ex.:x=ABCABBCAB \ BACA, qui est plus grand que BACy=CBACCCA /

Entrée: x=(x1...xn) et y=(y1...ym)Sortie: PLSC 7 de x,y

Solution nécessaire:Soit c[i,j] = longueur de la PLSC de xi et yi

/ 0 Si i=0 ou j=0c[i,j] = | c[i=1,j-1]+1 Si xi = yj et i>0, j>0

\ max(c[i-1,j], c[I,j-1]) Si xi != yj i>0, j>0

Note sur la correction de l'examen:

Pour prouver que la complexité de tout algo de tri par comparaison est dans (nlgn), il faut remarquer que peu importe l'algo, on aura en bout de compte lg(n!) permutations possibles, ce qui est dans (nlgn).


Le nombre de "bon parenthésage":

Le nombre de façons de les disposer correctement est donné par le nombre de Catalan: C(2n,n)/n+1

ou l'on peut noter que le nombre de BP est nombre total moins #nombre MP. #B = #P - #MP = C(2n,n) – C(2n,n+1)

Et ceci dépend du lemme:

Lemme: Il y a autant de mauvais parenthèsage que de parenthèsage avec n+1 '(' et n-1 ')' .

... à suivre.

Multiplication de matrices:

Problème: On a n matrices M1, M2, ..., Mn de dimensions di-1xdi pour Mi. On peut calculer M1xM2x...xMn.

M1xM2 d0xd1

Soit T(n) le nombre de manières de multiplier les n matrices (dans le bon ordre). Alors T(n) est lié au parenthésage.

T(n) = C(2n-2,n-1)/n

On recherche, quand on multiplie deux matrices de la suite, le minmum de multiplications à effectuer.

pour Mi x Mi+1 x Mi+k x Mi+s on calcule mi,i+s = min{ mi,i+k+mi+k+1,i+s+di-1di+kdi+s } *****

(on divise là où on a le nombre minimum, sachant qu'on aura déjà fait de façon optimale les sous- sections)

la matrice m des nombres de multiplications se rempli par, premièremet, la diagonale (aucune multiplication0) et ensuite les autres diagonales suivent: mij = mi,i+(i-j)

la valeur de m1,n nous donne la valeu totale recherchée.

Exemple: On a M1 à M5 et D=(2,5,10,10,4,2).

On va se fabriquer notre matrice de multiplications: grâce à: *****

diag 2: mi,i+1 = mi+1,i+1+di-1didi+1

diag 3: mi,i+2 = min{mi,i+mi+1,i+2+di-1didi+2 ,mi,i+1,mi+2,mi+2+di-1di+1di+2 }

diag 4: mi,i+3 = min{mi,i+mi+1,i+3+di-1didi+3 ,mi,i+2,mi+2,mi+2+di-1di+1di+3

mi,i+2+di-1di+1di+3 }diag 5: on suppose 420 pour simplifier.

Donc si on veut calculer de Mi à Ms on va couper à k, le k du cas minimum et ici on en aura au total 420.Nota: conserver s k quand on a trouvé le minimum.)

Le backtrack se fait en regardant la case k+1 dans la ligne suivante!

La complexité de ce calcul préalable:

1 2 3 4 51 0 100 300 380 4202 0 500 600 3803 0 400 2804 0 805 0


Retour sur l'intra:

ACM: Données: Un graphe pondéré par w:EBut: Trouver l'arbre couvrant minimum de G.

où un arbre est un graphe connexe sans cycle.arbre couvrant T de G à v(T)=V.minimum ...

Graphes:

Soit G=(V,E) un graphe.

Une composante connexe de G est un sous-graphe connexe maximal. (C'est-à-dire tel qu'on ne peut lui ajouter aucun autre sommet de G en le gardant conexe.)

(Fouille en profondeur ou en largeur)

Une composante 2-connexe est un sous-graphe 2-connexe maximal. Un graphe connexe est 2-connexe si l'enlèvement d'un sommet le garde connexe.

Prop: Un graphe est 2-connexe ssi pour tout u,v du graphe, il y a 2 chemins disjoints (sauf aux extrémités) entre u et v.

La fouille en profondeur est l'outil

Le point d'articulation sera trouvé dans l'arbre d'une fouille en profondeur lorsque on aura une étiquette qui sera ce point lui-même. On aura alors pris le soin de noter pour chaque sommet visité en étiquette le point le plus haut où il pourrait se rendre mais qui a déjà été visité ou l'tiquette revenant de la récurrence si elle est plus basse...

Cours 21, vendredi 31 mars 2006

Point d'articulation:

Un point d'articulation dans un graphe connexe G=(V,E) (non-orienté) est un sommet v V tel queG-v = (V\{v} | E\{uv|uv E}) est non connexe.

Définition: G est 2-connexe s'il n'a aucun point d'articulation.

Définition: Une composante C 2-connexe de G est un sous-graphe maximal 2-connexe de G où «maximal» veut dire que aucun sous-graphe H de G contenant c n'est 2-connexe.

(Il y a forcément une articulation entre les composantes.)

Mettre le meilleur résultat du précédent (pile?)

On a trouvé l'articulation quand le meilleur parmi les successeurs est égal à lui-même.

On ajuste les valeurs au retour de la récursion.

Définition: Un graphe est planaire si on peut le dessiner dans le plan sans que des arêtes se croisent.

Soit D = (V,A) un graphe orienté.

On dit que D est fortement connexe si pour toute paire u,v V2 de sommets, il existe un chemin orienté de u vers v et de v vers u.

Comment trouver les composantes fortement connexes de D? (exercice)

Question: Est-ce qu'il existe une numérotation des sommets v1 ... vn telle que vivj A i < j ? (un ordre topologique)

Lemme: D possède un ordre topologique ssi il est acyclique [DAG]. DAG=directed acyclic graph

Preuve: (1) Supposns que v1...vn est un ordre topologique. Soit vi1...vik un circuit alors vijvij+1 A et ij<ij+1. Par transitivité, i1 < ik mais vikvi1 A, donc ik < i1 , #contradiction#.(2) Soit D un DAG, alors l'algorithme suivant donne un ordre topologique: (bla)

Résoudre un problème:

Trouver un algorithme A(Avec les Données et le But)Prouver que A fonctionneTrouver le temps (espace) d'exécution de A (en termes de la longueur de l'entrée)Prouver(!) que l'on ne peut pas faire mieux.

Soit P un problème et soit A la classe d'algorithmes qui le résolvent. infimum (inf) est la limite du min.La complexité (temps) de P est inf{ tA(n) | l'algorithme A a s'exécute en temps tA(n) sur un exemplaire de n }.

Ex.:Tri.Données: n clésBut: Soit une liste c1...cn tel que ci ≤ ci+1 ...Un algorithme donne une borne supérieure sur ct(tri). E.g. ct(tri) O(n2) par bubblesort O(nlgn) par merge.

ct(tri) (n) car il faut visiter toutes les clésct(tri) (nlgn) parce qu'il faut se construire un arbre de comparaison de log n de hauteur (n! ordres).

Un problème est polynomial s'il existe un k tel que ct(P) O(nk)

Démo 9, lundi 3 avril 2006

Ex.1: Retourner la monnaie:On veut rendre la monnaie à un client dans un magasin en utilisant le plus petit nombre de pièces.

Étant donnés une somme N à rendre et n pièce, chaque pièce est nomméepar i=1...n et de valeur d i > 0, i≤i≤n. On suppose le nombre de pièces illimité.

Soit C[i,j], le nombre minimal de pièces pour payer une somme j en utilisant seulement des pièces de 1...i.

À l'itération i: Si je prend i, 1+c[i,j-di]Sinon c[i-1,j]

C[0,j] = + 1≤j≤NC[i,0] = 0 1≤i≤n

C[i,j]= / C[i-1,j] Si j<di

\ min(C[i-1,j], 1+C[i,j-di])

but:C(n,N)

Exemple: n=3 N=8 d={1,4,6}

c[I,j] 1≤i≤n 1≤j≤N

c[3,8] = min( c[2,8], 1+c[3,2] )c[2,1] = min( c[1,1], 1+c[2,0] )c[2,4] = min( c[1,4], 1+c[2,0] ) = min(4,1+0)

i \ j 0 1 2 3 4 5 6 7 81 (1) 0 1 2 3 4 5 6 7 82 (4) 0 1 2 3 1 2 3 4 23 (6) 0 1 2 3 1 4 1 2 2

Donc 2 pièces. Le backtrack nous dit que le 2 vient de (2,8) qui lui vient de (2,4)+(2,0)Complexité: Pour calculer tous les c[i,j], on a (n*N).

Pour retrouver son chemin, on a (n+c[n,N])

Note: Ne pas oublier que dans la ligne, tant qu'on n'a pas atteint la valeur, rien ne change!

Ex.2: Sac à dos:On a n objets de poids w1...wn et de valeurs v1...vn. La valeur maximale du sac et W.

But:Déterminer x1...xn tel que en maximisant la valeur de .

xi = 1 si on prend l'objet i, xi = 0 sinon. ( vi > 0, wi > 0 )Nous résolvons le problème par la programmation dynamique.

Soit v[i,j] = la valeur maximale des objets qu'on peut prendre dns un sac de capacité j si on ne prend que des objets ≤ i. (Les objets sont nommés par 1,2,3...)

Si i inclus: v[i,j] = v[i-1,j-wi] + vi

Sinon: v[i,j] = v[i-1,j]v[I,j] = - j<0v[I,j] = max(v[i-1,j], v[i-1,j-wi] + vi)

Exemple: v={1,6,18,22,28}w={1,2,5,6,7}

i \ j 0 1 2 3 4 5 6 7 8 9 10 111 0 1 1 1 1 1 1 1 1 1 1 12 0 1 6 7 7 7 7 7 7 7 7 73 0 1 6 7 7 18 19 24 25 25 25 254 0 1 6 7 7 18 22 24 28 29 29 405 0 1 6 7 7 18 22 28 29 34 35 40

v[5,11] = max( v[4,11],v[4,4] + 28) = max(40,7+28)etc.

Complexité du calcul de tous les v[i,j]: (nw)

x5 = 0 x4 = 1 x3 = 1 x2 = x1 = 0

Pour retrouver la solution: (n + w)

Correction devoir 7:

Ex.1: Si k = n, Une seule itération, nombre de récurrences =02(n

k)-2=21-2

Si k < n, par induction mathématiqueSi n = 1 2(1

0) -2 =0

On suppose que l'équationest vraie pour tout k<l<n:

Fonction c(n,k)Si k=0 ou k=n retourner 1Sinon retourner c(n-1,k-1) + c(n-1,k)

Le nombre de récurrences pour n est:2(n-1

k-1)-2+2(n-1k) -2 +2 = 2((n-1

k-1)-(n-1k)) -2 = 2(n

k)-2

Ex.4: p(x) = 2 + x + 2x3 et q(x) = x + 2x2 ( devrait donner: 2x + 5x2 + 2x3 2x4 + 22x5 )

On a n=8. a=[2,1,0,2,0,0,0,0] b=[0,1,2,0,0,0,0,0]

[2,0,0,0] [1,2,0,0][2,0] [0,0] [1,0] [2,0]

F [2,2] [0,0] [1,1] [2,2][2,2,2,2] [1+2,1+i2,1-2,1-i2][3+2,

Démo 10, vendredi 7 avril 2006

parcours en profondeurpour chaque sommet u V

faire couur[u] blancp[u] nultemps 1

pour tout u V fairesi couleur[u] == blancvisiter-pp(u)

visiter-pp(u)couleur[u] grisd[u] tempstemps++pour tout v Adj[u]

Si couleur[v] == blancp[v] uvisiter-pp(v)

couleur[u] noirf[u] noirtemps++

d[u] = date du début de traitement de uf[u] = date de fin de traitement de u

(On marque au premier passage en gris et auretour on noirci. Quand tout est noir:terminé temps t)

parcours en largeurpour chaque sommet u V\{s} faire

couleur[u] blancd[u]

couleur[s] grisd[s] 0F {s}

Tant que |F| > 0 faireu tête(F)pour tout v Adj[u] faire

Si couleur[v] == blanccouleur[v] grisd[v] d[u] + 1Enfiler(F,v)

defiler(F)couleur[u] noir

point d'articulation: un point tel que si on le supprime (avec ses arcs adjacents) le graphe n'est plus connexe.On peut déterminer les points d'articulation avec un parcours en profondeur.

v est un point d'articulation de G ssi v possède un fils u tel qu'il n'existe aucune arête retour partant de u ou d'un descendant de v et arrivant à un ancêtre de v.

tri-topologique(G)parcours-profondeur(G)

Ordonner les temps de fin de traitement f[v]

Le tri topologique d'un graphe G consiste à ordonner linéairement tous les sommets de sorte que si G contient un arc(u,v) u aparraisse avant v.

exemple: Le savant Sinus qui s'habille le matin...

Temps de traitement: (début/fin)

tri des temps de fin (ordre décroissant):montre,chaussettes,caleçon,pantalon,chaussures,chemise,cravate,veste.

Définition: Réduire le problème de décision A au problème de décision B c'est construire un algorithme qui transforme toute instance u de A en une instance v=f(u) de B tel que: A(u) = B(f(u)). Si B est dans P et si la transformation f est polynomiale, alors A est aussi dans P.

Cours 22, lundi 10 avril 2006

Complexité:

Problème:Données [ ] nous donne la taille du problèmeBut ( ) Question à laquelle la réponse est oui ou non

Données: G(V,E) (non pondéré) par exempleQuestion: Quel est le plus grand sous-graphe complet?

Q1: ? un sous-graphe complet de k sommets? polynomial ...

Question: Trouver le plus grand sous-graphe sans arête.(On va trouver le graphe complémentaire et on utilise ce qu'on a trouvé à la précédente question).

Question: Quel est le nombre chromatique de G?Le nombre chromatique de G, noté (G) = min {k|on peut colorier tous les sommets sans que 2 côte à

côte ait la même couleur}Q1: ? coloration de c:V(G) [k] = {0,...,k-1}?

Nota: Une solution rapide est une solution «en temps polynômial»

Définition: La classe P est la classe de problèmes dont la solution peut être obtenue en temps polynômial.

Définition: La classe NP est la classe de problèmes dont la solution peut être vérifiée en temps polynomiale.

Observation: P NP (Si je peux trouver la solution, je peux forcément la vérifier en temps polynomial.)

Ex.: ? G contient un cycle hamiltonien? (Passe par tous les sommets une seule fois)Ex.: ? un cycle hamiltonien de coût k dans un G pondéré? w:E(G)N?Ex.: min cx ...

Définition: Un problème P se réduit polynômialement à un problème Q s'il existe une fonction qui transforme en temps polynômial un exemplaire P^ de P en un exemplaire Q^ de Q de façon à ce que Q^ ait la réponse OUI ssi P^ a la même réponse.

Ex.:Sous-graphe complet de taille k sous-graphe sans arête de taille k ...

Appelons CLIQUE(G,k) le problème D: "G=(V,E),k"Q: ? un sous-graphe complet de k sommets?

STABLE(G,k) le problème D: "G=(V,E),k"Q: ? un sous-graphe sans arête de k sommets?

On dira donc que CLIQUE(G,k) se réduit à STABLE(G,k) et STABLE(G,k) se réduit à CLIQUE(G,k).On écrit: CLIQUE(G,k) ≤ STABLE(G,k) et STABLE ≤ CLIQUE(G,k)

Ex.:VERTEX COVER (G,k)D: G=(V,E),k (|V|=n)Q: ? S V, |S| ≤ k tel que toute arête a au moins une extrémité dans S.

On observe que VC(G,k) se réduit à STABLE( , )S est un VC V\S est un stable.

Définition: Un problème P est NP-complet si:- On peut vérifier sa solution en temps polynômial PNP- Q NP, Q≤P

Théorème: [Cook, Levine]Un problème NP-complet existe et c'est SAT.

SAT: Données: Une formule booléenne en forme normale conjonctive.But: Est-ce que es satisfaisable.

Clause: (x1 v x2 v x3 v x4)

= (x1 v x2 v x3 v x4) ^ (x1 v x15 ...) ^ ( ) ^ ( )

Définition: NPC est la classe de problèmes NP-complet

Observation: Si P NP et si SAT ≤ P alors P NPC

Ex.: Prouver que si SAT ≤ P et SAT ≤ R alors P ≤ R et R ≤ P, prouver que ,R NP

Fin du cours

Révision, mercredi 19 avril 2006:

Définition de problème: Données + But(Question).En plus, on va essayer de trouver une question qui se répond par oui ou non.

Ne pas confondre avec un exemplaire.

P/NP: P est un problème solvable en temps polynomial, à savoir que l'ordre de grandeur du temps de calcul d'un algorithme connu est un polynome (pas exponentiel ou pire).

NP: Dont on peut deviner la solution et la tester en temps polynomial

NPC: La classe des problèmes à laquelle on peut réduire polynomialement tous les problèmes de NP de façon à ce que la réponse du problème réduit soit oui ssi la réponse du problème original est oui..

1. Définir! 2. Poser des questions!3. O(f), (f), (f)4. des méthodes de résolution des récurrences.5. P, NP, NPC.

a. Ce qui est intéressant si on ourne en rond, c'est d'essayer de prouver que notre problème NP est NPC (donc difficile)6. Analyse de complexité

a. pire casb. (en moyenne)

7. Preuves (du bon foncitonnement d'un algorithme)8. Méthodes principales

a. Diviser pour régneri. Fourrier par exemple

b. Programmation dynamiquei. Principe d'optimalité

c. Gloutonsd. (Méthodes probabilistes))

ngrenon/udem/cours/ift2121/notes de cours... · web viewcours ift2121 – introduction à...

Documents