Sommaire

0. Ce fichier : mises à jour, corrections Python 2 → 3, plan de révision, sources
1. Grand O
2. Recherche dichotomique
3. Mémoire, tableaux et listes chaînées
4. Récursivité et pile d'appels
5. Diviser pour régner et tris
6. Tables de hachage
7. Graphes et parcours en largeur (BFS)
8. Plus courts chemins : Dijkstra et Bellman-Ford
9. Algorithmes gloutons et problèmes NP
10. Programmation dynamique
11. k plus proches voisins et machine learning
12. Arbres
13. Pour aller plus loin (Grokking ch. 11 et CLRS)
14. Aide-mémoire final

Chaque fiche suit le même plan : idée en une phrase, explication, code Python 3 testé, complexité, pièges, exercices corrigés, renvoi aux livres.

Conventions : n = nombre d'éléments, V = sommets, E = arêtes. Les complexités sont écrites en texte simple (O(n log n)) pour s'afficher partout, sans LaTeX. Les numéros de chapitres CLRS suivent la 3e édition, sauf mention contraire.

Corriger le code de ton PDF Grokking (Python 2 → 3)

• print x devient print(x).
• mid = (low + high) / 2 devient mid = (low + high) // 2 (en Python 3, / donne un décimal : erreur d'indice).
• raw_input() devient input().
• Depuis Python 3.7, un dict conserve l'ordre d'insertion.

Plan de révision en 4 semaines

1. Semaine 1 : fiches 1 à 4. Recoder dichotomie, liste chaînée, récursivité.
2. Semaine 2 : fiches 5 à 7. Recoder tri fusion, quicksort, BFS avec chemin.
3. Semaine 3 : fiches 8 à 10. Remplir à la main la grille du sac à dos.
4. Semaine 4 : fiches 11 à 14, puis refaire tous les exercices sans regarder.

Sources

• Grokking Algorithms, 2e éd. : https://www.oreilly.com/library/view/grokking-algorithms-second/9781633438538/ et https://bookshop.org/p/books/grokking-algorithms-second-edition-aditya-y-bhargava/c5a7ae7af8d74525
• CLRS, 4e éd. : https://ereader.exlibris.ch/de/buecher-buch/englische-ebooks/thomas-h-cormen/introduction-to-algorithms-fourth-edition/id/9780262367509 ; FAQ de Thomas Cormen https://www.cs.dartmouth.edu/~thc/ ; entretien du MIT https://news.mit.edu/index.php/2022/qa-what-makes-bestselling-textbook-introduction-algorithms-0223
• Contenu du chapitre ML de CLRS 4e éd. : résumés tiers (par ex. https://lastminutelecture.blogspot.com/2025/06/machine-learning-algorithms-kmeans-gradient-descent.html), à vérifier dans le livre.
• Duan et al., Breaking the Sorting Barrier for Directed Single-Source Shortest Paths : https://arxiv.org/abs/2504.17033
• Les points non sourcés ci-dessus (Python 3, Timsort, SHA-1, ECDH, lru_cache, heapq) relèvent de connaissances générales : à vérifier dans la documentation officielle si besoin.

Corrections par rapport aux versions précédentes

Cette version corrige les erreurs repérées lors de la revue : exemple de planification de la fiche gloutons, réponses « nombre d'étapes » de la dichotomie (formule exacte : floor(log2 n) + 1), mémoire du tri rapide, distinction NP-difficile / NP-complet, BFS qui reconstruit le chemin, KeyError sur les graphes, récursivité sur liste vide, titre « plus longue sous-chaîne ».

Revue du 10 novembre 2026 : tout le code a été réexécuté (Python 3.15) avec des tests ; corrections sur la hauteur d'un arbre (niveaux contre arêtes), le nombre de comparaisons du tri par sélection, l'usage de bisect_left, la définition du tas, un exemple de graphe pour Dijkstra, la limite de pile de lru_cache, et le corrigé de l'exercice compter (sans copie de liste).

Explication

Pour chercher un nom dans une liste de n éléments :

• Recherche simple : on regarde les éléments un par un, jusqu'à n essais → O(n).
• Recherche dichotomique (liste triée) : on élimine la moitié à chaque étape → O(log n).

Sur 100 éléments la différence est minime ; sur 1 milliard, c'est 1 milliard d'étapes contre une trentaine.

Définition (un peu plus formelle)

T(n) = O(f(n)) signifie qu'à partir d'une certaine taille, T(n) ne dépasse pas un multiple constant de f(n).

• On ignore les constantes : 3n, 100n et n sont tous O(n).
• On ignore les termes secondaires : n² + 100n + 7 est O(n²).
• Exemple : 2n² + 500n + 10 opérations → O(n²).

Les complexités courantes (du plus rapide au plus lent)

Les logarithmes simplement

log2 n répond à : « combien de fois diviser par 2 pour arriver à 1 ? ». Ex. 8 → 4 → 2 → 1 : log2 8 = 3.

Précision utile : le nombre maximal d'étapes de la dichotomie sur n éléments est floor(log2 n) + 1. Ex. : 100 → 7 ; 128 → 8 ; 1 024 → 11. Dans le Grand O, cette différence de 1 disparaît.

Pire cas, meilleur cas, cas moyen

• Pire cas : la situation la plus défavorable (c'est celle que le Grand O décrit par défaut).
• Meilleur cas : la plus favorable (trouver tout de suite).
• Cas moyen : le comportement typique.

Trois notations (CLRS ch. 3)

• O : borne supérieure (« au plus »).
• Ω (oméga) : borne inférieure (« au moins »).
• Θ (thêta) : borne serrée (les deux à la fois).

Code : repérer la complexité

def afficher(liste):            # O(n) : une boucle
    for element in liste:
        print(element)

def comparer_paires(liste):     # O(n²) : deux boucles imbriquées
    for a in liste:
        for b in liste:
            print(a, b)

premier = [10, 20, 30][0]       # O(1) : accès direct

Méthode

1. Repérer la taille de l'entrée. 2. Compter les boucles. 3. Repérer les boucles imbriquées. 4. Garder le terme dominant. 5. Ignorer les constantes. 6. Préciser le cas étudié.

Principe

1. Regarder le milieu. 2. Si c'est la cible, renvoyer son indice. 3. Si la cible est plus petite, chercher à gauche. 4. Si elle est plus grande, chercher à droite. 5. Répéter jusqu'à trouver ou jusqu'à ce que la zone soit vide.

Exemple : chercher 7 dans [1, 3, 5, 7, 9] : milieu = 5 (< 7) → zone [7, 9] → milieu = 7 : trouvé à l'indice 3.

Code Python 3

def recherche_dichotomique(liste, cible):
    bas, haut = 0, len(liste) - 1
    while bas <= haut:
        milieu = (bas + haut) // 2      # // et non / en Python 3
        valeur = liste[milieu]
        if valeur == cible:
            return milieu
        elif valeur < cible:
            bas = milieu + 1
        else:
            haut = milieu - 1
    return None

En pratique, le module standard bisect fait ce travail. Attention : bisect_left renvoie une position d'insertion, pas « trouvé / pas trouvé » ; il faut vérifier :

from bisect import bisect_left

def chercher(liste, cible):
    i = bisect_left(liste, cible)
    return i if i < len(liste) and liste[i] == cible else None

Complexité

Nombre maximal d'étapes : floor(log2 n) + 1.

Explication

La mémoire est une armoire à tiroirs numérotés.

• Tableau : éléments côte à côte. L'adresse du i-ème se calcule directement : lecture instantanée. Insérer au milieu oblige à décaler les suivants. Tous les éléments ont le même type.
• Liste chaînée : éléments dispersés, chacun contient l'adresse du suivant. Insérer ou supprimer = changer un lien. Pour atteindre le 100e, il faut passer par les 99 premiers.

Image de Grokking : un tableau, c'est réserver des places côte à côte au cinéma (impossible d'ajouter un ami si la rangée est pleine) ; une liste chaînée, c'est être dispersés dans la salle, chacun sachant où est le suivant.

Terminologie

• Accès aléatoire : aller directement à l'élément i (tableaux).
• Accès séquentiel : lire dans l'ordre (listes chaînées).

Code : liste chaînée

class Noeud:
    def __init__(self, valeur):
        self.valeur = valeur
        self.suivant = None

class ListeChainee:
    def __init__(self):
        self.tete = None

    def ajouter_debut(self, valeur):          # O(1)
        nouveau = Noeud(valeur)
        nouveau.suivant = self.tete
        self.tete = nouveau

    def rechercher(self, valeur):             # O(n)
        courant = self.tete
        while courant is not None:
            if courant.valeur == valeur:
                return courant
            courant = courant.suivant
        return None

    def supprimer(self, valeur):              # O(n) pour trouver, O(1) pour délier
        precedent, courant = None, self.tete
        while courant is not None:
            if courant.valeur == valeur:
                if precedent is None:
                    self.tete = courant.suivant
                else:
                    precedent.suivant = courant.suivant
                return True
            precedent, courant = courant, courant.suivant
        return False

    def vers_liste(self):
        resultat, courant = [], self.tete
        while courant is not None:
            resultat.append(courant.valeur)
            courant = courant.suivant
        return resultat

Comparaison

Quand choisir quoi ?

• Accès fréquent par position, ou dichotomie → tableau.
• Beaucoup d'insertions / suppressions en tête → liste chaînée.
• File d'attente : en Python, collections.deque.

Pour aller plus loin

• CLRS ch. 10 : piles, files, listes simplement, doublement et circulairement chaînées.
• Le list de Python est un tableau dynamique : ajouter à la fin coûte O(1) en moyenne (analyse amortie, CLRS ch. 17), insérer au début coûte O(n).
• Sur les machines actuelles, les tableaux profitent mieux du cache du processeur : un point que Grokking 2e éd. développe.

Explication

Pour savoir si une boîte contient une clé : on l'ouvre ; si elle contient d'autres boîtes, on applique la même méthode à chacune.

Toute fonction récursive a deux parties :

1. Cas de base : cas si simple qu'on répond directement (la récursion s'arrête).
2. Cas récursif : on se ramène à un problème plus petit.

def factorielle(n):
    if n <= 1:                       # cas de base
        return 1
    return n * factorielle(n - 1)    # cas récursif

def somme(liste):
    if not liste:                    # cas de base : liste vide
        return 0
    return liste[0] + somme(liste[1:])

Déroulé de somme([2, 4, 6]) : 2 + (4 + (6 + somme([]))) = 12.

La pile d'appels

• Une pile est une structure LIFO (dernier entré, premier sorti) avec deux opérations : push (empiler) et pop (dépiler).
• Chaque appel de fonction empile un cadre (variables locales, point de retour). Quand l'appel se termine, son cadre est dépilé.
• Avec la récursivité, la pile peut devenir très haute : coût mémoire, et erreur RecursionError si on dépasse la limite (1 000 par défaut dans CPython).
• Python n'optimise pas la récursion terminale.

Version sans copies (meilleure pratique)

liste[1:] copie la liste à chaque appel : somme devient O(n²). Avec des indices, on reste en O(n) :

def somme_indices(liste, i=0):
    if i == len(liste):
        return 0
    return liste[i] + somme_indices(liste, i + 1)

def maximum(liste, i=0):
    if not liste:
        raise ValueError("liste vide")
    if i == len(liste) - 1:
        return liste[i]
    reste = maximum(liste, i + 1)
    return liste[i] if liste[i] > reste else reste

Récursivité ou boucle ?

Pour aller plus loin (CLRS ch. 4)

Pour analyser un algorithme récursif, on écrit une récurrence : T(n) = 2T(n/2) + n (tri fusion) donne Θ(n log n). Le théorème maître résout T(n) = aT(n/b) + f(n). La 4e édition a retravaillé cette partie.

Diviser pour régner (Grokking ch. 4)

1. Trouver le cas de base (très simple : liste vide ou à un élément).
2. Réduire le problème jusqu'à l'atteindre.

Exemples : partager un terrain en carrés égaux les plus grands possibles (algorithme d'Euclide) ; additionner une liste = premier élément + somme du reste.

Comparaison des tris

Tri par sélection

On cherche le plus petit élément restant et on le place en tête.

def tri_selection(liste):
    for i in range(len(liste) - 1):
        indice_min = i
        for j in range(i + 1, len(liste)):
            if liste[j] < liste[indice_min]:
                indice_min = j
        liste[i], liste[indice_min] = liste[indice_min], liste[i]
    return liste

Coût : (n-1) + (n-2) + ... + 1 = n(n-1)/2 comparaisons, donc O(n²).

Tri par insertion

On insère chaque élément à sa place dans la partie déjà triée. Très rapide sur de petites listes ou des listes presque triées.

def tri_insertion(liste):
    for i in range(1, len(liste)):
        cle = liste[i]
        j = i - 1
        while j >= 0 and liste[j] > cle:
            liste[j + 1] = liste[j]
            j -= 1
        liste[j + 1] = cle
    return liste

Tri fusion

On coupe en deux, on trie chaque moitié, on fusionne. Toujours O(n log n).

def tri_fusion(liste):
    if len(liste) <= 1:
        return liste
    milieu = len(liste) // 2
    return fusionner(tri_fusion(liste[:milieu]), tri_fusion(liste[milieu:]))

def fusionner(gauche, droite):
    resultat, i, j = [], 0, 0
    while i < len(gauche) and j < len(droite):
        if gauche[i] <= droite[j]:
            resultat.append(gauche[i]); i += 1
        else:
            resultat.append(droite[j]); j += 1
    resultat.extend(gauche[i:])
    resultat.extend(droite[j:])
    return resultat

Quicksort (tri rapide)

1. Choisir un pivot. 2. Partitionner : plus petits à gauche, plus grands à droite. 3. Trier les deux côtés récursivement.

Version « listes » (lisible, mais O(n) de mémoire) :

import random

def tri_rapide(liste):
    if len(liste) <= 1:
        return liste
    pivot = random.choice(liste)            # pivot aléatoire
    petits = [x for x in liste if x < pivot]
    egaux = [x for x in liste if x == pivot]
    grands = [x for x in liste if x > pivot]
    return tri_rapide(petits) + egaux + tri_rapide(grands)

Version en place (O(log n) de pile) : on récurse sur le plus petit côté et on boucle sur l'autre.

import random

def tri_rapide_en_place(a, bas=0, haut=None):
    if haut is None:
        haut = len(a) - 1
    while bas < haut:
        p = random.randint(bas, haut)
        a[p], a[haut] = a[haut], a[p]
        pivot, i = a[haut], bas
        for j in range(bas, haut):
            if a[j] < pivot:
                a[i], a[j] = a[j], a[i]
                i += 1
        a[i], a[haut] = a[haut], a[i]
        if i - bas < haut - i:
            tri_rapide_en_place(a, bas, i - 1)
            bas = i + 1
        else:
            tri_rapide_en_place(a, i + 1, haut)
            haut = i - 1
    return a

Pourquoi un pivot aléatoire ?

Avec toujours le premier élément comme pivot, une liste déjà triée donne des partitions déséquilibrées (0 et n-1 éléments) : O(n²). Un pivot aléatoire rend ce cas très improbable : CLRS ch. 7 montre un temps moyen espéré de O(n log n) quelle que soit l'entrée. Attention : la version en place ci-dessus dégrade en O(n²) si tous les éléments sont égaux ; la version « listes » gère bien les doublons grâce à egaux.

Pourquoi quicksort bat souvent le tri fusion

Les deux sont O(n log n) en moyenne, mais la constante du quicksort est plus petite. Le Grand O ignore les constantes ; elles comptent pourtant.

Pour aller plus loin (CLRS)

• Borne inférieure (ch. 8) : tout tri par comparaisons demande Ω(n log n).
• On fait mieux (O(n)) seulement avec d'autres hypothèses : tri par dénombrement, par base (radix), par paquets.
• Mise à jour pratique : sorted() et list.sort() de Python utilisent Timsort (hybride fusion + insertion, stable), pas quicksort. Dans un vrai projet, utilise-les.
• Stable = conserve l'ordre des éléments égaux ; en place = peu de mémoire supplémentaire. Ce sont deux notions différentes.

Explication

Une fonction de hachage transforme une clé (mot, nom…) en un indice de tableau, comme un annuaire où le nom donne directement la page.

Une bonne fonction de hachage :

• est déterministe (même clé, même indice, toujours) ;
• répartit les clés uniformément dans le tableau ;
• associe, autant que possible, des clés différentes à des cases différentes.

Cas d'usage (Grokking)

1. Associer une clé à une valeur (annuaire).
2. Éviter les doublons (« ai-je déjà vu cette valeur ? »).
3. Cache : mémoriser un résultat déjà calculé.

annuaire = {"alice": "alice@exemple.fr", "bob": "bob@exemple.fr"}
annuaire["carole"] = "carole@exemple.fr"

def compter_mots(texte):
    compteur = {}
    for mot in texte.split():
        compteur[mot] = compteur.get(mot, 0) + 1
    return compteur

def sans_doublons(liste):
    vus, resultat = set(), []
    for x in liste:
        if x not in vus:
            vus.add(x)
            resultat.append(x)
    return resultat

cache = {}
def carre_lent(n):                 # exemple de cache
    if n not in cache:
        cache[n] = n * n           # imagine un calcul coûteux
    return cache[n]

Collisions et performance

• Collision : deux clés tombent dans la même case.
• Chaînage (Grokking) : chaque case contient une liste de paires clé-valeur.
• Adressage ouvert : si la case est occupée, on cherche une autre case libre.
• Facteur de charge = nombre d'éléments / nombre de cases. Grokking conseille de redimensionner quand il dépasse environ 0,7.

Le pire cas arrive quand tout s'entasse dans la même case (mauvaise fonction de hachage).

Pour aller plus loin (CLRS ch. 11)

• Hachage universel : choisir la fonction au hasard dans une famille pour éviter les entrées « piégées ».
• Hachage parfait : O(1) garanti au pire cas pour un ensemble de clés fixe.
• Mise à jour : en Python, dict utilise l'adressage ouvert, pas le chaînage de Grokking. Depuis Python 3.7, il garde l'ordre d'insertion.

Vocabulaire

• Sommet (nœud) : un objet. Arête : un lien.
• Orienté : le lien a un sens (A doit de l'argent à B). Non orienté : relation dans les deux sens.
• File : structure FIFO (premier entré, premier sorti). Pile : LIFO.

Représentation (liste d'adjacence, via un dict)

graphe = {
    "vous": ["alice", "bob", "claire"],
    "alice": ["peggy"],
    "bob": ["peggy", "anuj"],
    "claire": ["thom", "jonny"],
    "peggy": [], "anuj": [], "thom": [], "jonny": [],
}

Principe du BFS

1. Mettre le départ dans une file. 2. Retirer le premier sommet. 3. Examiner ses voisins. 4. Ajouter à la file ceux pas encore vus. 5. Répéter jusqu'à trouver la cible ou vider la file.

La file garantit qu'on traite d'abord les voisins directs, puis les voisins des voisins : le premier chemin trouvé est donc le plus court en nombre d'arêtes.

Code : BFS qui renvoie le chemin

from collections import deque

def plus_court_chemin(graphe, depart, cible):
    parents = {depart: None}
    file = deque([depart])
    while file:
        sommet = file.popleft()
        if sommet == cible:
            chemin = []
            while sommet is not None:
                chemin.append(sommet)
                sommet = parents[sommet]
            return chemin[::-1]
        for voisin in graphe.get(sommet, []):     # .get : pas de KeyError
            if voisin not in parents:
                parents[voisin] = sommet
                file.append(voisin)
    return None

parents joue aussi le rôle de l'ensemble des sommets déjà vus.

Complexité

O(V + E) : chaque sommet et chaque arête sont examinés une fois.

Pour aller plus loin (CLRS ch. 22)

• CLRS colore les sommets (blanc, gris, noir) et calcule les distances et prédécesseurs.
• Parcours en profondeur (DFS) : explore à fond avant de revenir (pile ou récursivité). Il sert au tri topologique (ordonner des tâches avec dépendances) et aux composantes fortement connexes.
• Liste d'adjacence (graphes peu denses) ou matrice d'adjacence (graphes denses).

Exemple

A -> B : 5 minutes
A -> C : 2 minutes
C -> B : 1 minute

A -> C -> B coûte 3 minutes, A -> B coûte 5 : Dijkstra choisit A -> C -> B.

Principe

1. Coût du départ = 0, tous les autres = infini.
2. Prendre le sommet non traité de coût minimal.
3. Mettre à jour ses voisins si passer par lui est moins cher (et noter le parent).
4. Répéter jusqu'à avoir traité tous les sommets accessibles.
5. Reconstruire le chemin avec les parents.

Grokking utilise trois tables de hachage : le graphe, les coûts et les parents, plus une liste des sommets traités.

Code Python 3

import heapq

def dijkstra(graphe, depart):
    couts = {depart: 0}
    parents = {depart: None}
    tas = [(0, depart)]
    while tas:
        cout, sommet = heapq.heappop(tas)
        if cout > couts.get(sommet, float("inf")):
            continue                              # entrée périmée
        for voisin, poids in graphe.get(sommet, {}).items():
            nouveau = cout + poids
            if nouveau < couts.get(voisin, float("inf")):
                couts[voisin] = nouveau
                parents[voisin] = sommet
                heapq.heappush(tas, (nouveau, voisin))
    return couts, parents

def reconstruire_chemin(parents, cible):
    if cible not in parents:
        return None
    chemin = []
    while cible is not None:
        chemin.append(cible)
        cible = parents[cible]
    return chemin[::-1]

graphe = {"A": {"B": 5, "C": 2}, "C": {"B": 1}}   # sommet -> {voisin: poids}
couts, parents = dijkstra(graphe, "A")
print(couts["B"], reconstruire_chemin(parents, "B"))   # 3 ['A', 'C', 'B']

Règles d'or

• BFS : sans poids. Dijkstra : poids ≥ 0. Bellman-Ford : poids négatifs permis.
• Avec un poids négatif, Dijkstra peut se tromper : un sommet déjà « fini » pourrait encore être amélioré.
• Dans un graphe non orienté, chaque arête est un cycle : sans importance tant que les poids sont positifs.

Bellman-Ford (poids négatifs)

def bellman_ford(sommets, aretes, depart):
    d = {s: float("inf") for s in sommets}
    d[depart] = 0
    for _ in range(len(sommets) - 1):
        for u, v, w in aretes:
            if d[u] + w < d[v]:
                d[v] = d[u] + w
    for u, v, w in aretes:                        # détection de cycle négatif
        if d[u] + w < d[v]:
            raise ValueError("cycle de poids négatif")
    return d

Complexité

Exemple qui marche : planning de réunions

On veut placer le plus de réunions sans chevauchement. Stratégie : prendre celle qui finit le plus tôt, puis la suivante compatible.

Résultat : Art, Maths, Musique = 3 réunions, ce qui est le maximum ici.

def planning(reunions):
    """reunions : liste de (nom, debut, fin) ; heures en décimal (9.5 = 9 h 30)."""
    choisies, fin_derniere = [], float("-inf")
    for nom, debut, fin in sorted(reunions, key=lambda r: r[2]):
        if debut >= fin_derniere:
            choisies.append(nom)
            fin_derniere = fin
    return choisies

Exemple qui échoue : sac à dos (0/1)

Sac de 35 kg. Glouton « le plus cher d'abord » : hi-fi (30 kg), il reste 5 kg, rien d'autre ne rentre : 3 000 €. Mieux : ordinateur + guitare = 35 kg, 3 500 €. Le glouton n'est donc ici qu'une approximation. Pour le sac à dos 0/1, utilise la programmation dynamique (fiche 10). Pour le sac à dos fractionnable, trier par valeur/poids est optimal.

Couverture d'ensemble (Grokking)

Choisir le moins de stations de radio possible pour couvrir tous les États voulus : à chaque tour, prendre la station qui couvre le plus d'États pas encore couverts.

def couverture(etats_voulus, stations):
    restants, choix = set(etats_voulus), []
    while restants:
        meilleure, couverts = None, set()
        for station, etats in stations.items():
            nouveaux = restants & etats
            if len(nouveaux) > len(couverts):
                meilleure, couverts = station, nouveaux
        if meilleure is None:
            raise ValueError("couverture impossible")
        restants -= couverts
        choix.append(meilleure)
    return choix

La solution est proche de l'optimum, pas garantie optimale.

Problèmes NP : vocabulaire précis

• P : problèmes résolubles en temps polynomial (rapide).
• NP : problèmes dont une solution proposée se vérifie rapidement.
• NP-difficile : au moins aussi dur que tous les problèmes de NP (n'est pas forcément dans NP).
• NP-complet : NP-difficile et dans NP. Aucun algorithme rapide connu ; savoir si P = NP reste une question ouverte (l'un des problèmes du prix du millénaire).
• Exemples classiques : voyageur de commerce, couverture d'ensemble, couverture par sommets, SAT, sac à dos (version exacte).

Comment les repérer (Grokking)

Rapide avec peu d'éléments, très lent dès qu'on en ajoute ; on te demande « toutes les combinaisons de X » ; ça ressemble au voyageur de commerce ou à la couverture d'ensemble.

Que faire ?

Un algorithme d'approximation : rapide, proche de l'optimum. Un glouton est un bon candidat. Autres options : heuristiques, programmation dynamique sur des cas restreints.

Pour aller plus loin (CLRS)

• Quand le glouton est-il correct ? Il faut la propriété de choix glouton et la sous-structure optimale (ch. 16). Exemples : sélection d'activités, codage de Huffman, arbres couvrants de poids minimal (Kruskal, Prim, ch. 23).
• NP-complétude (ch. 34) : réductions polynomiales. Approximation (ch. 35) : par exemple, facteur 2 pour la couverture par sommets.
• Le chapitre sur les gloutons a été remanié dans la 4e édition.

Quand l'utiliser ?

• Sous-structure optimale : la solution optimale contient des solutions optimales de sous-problèmes.
• Sous-problèmes qui se chevauchent : on les rencontre plusieurs fois.
• Les sous-problèmes sont indépendants et discrets : on ne peut pas voler une fraction d'objet (dans ce cas, un glouton suffit).

Le sac à dos (exemple de Grokking)

Capacité 4 kg. Meilleur choix : guitare + ordinateur = 3 500 €.

Grille : chaque ligne ajoute un objet, chaque colonne est une capacité (1 kg, 2 kg…). Chaque case = meilleure valeur possible. case = max( case_du_dessus , valeur_objet + case_du_dessus_avec_capacité_restante )

def sac_a_dos(poids, valeurs, capacite):
    n = len(poids)
    table = [[0] * (capacite + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        for w in range(capacite + 1):
            table[i][w] = table[i - 1][w]
            if poids[i - 1] <= w:
                table[i][w] = max(table[i][w],
                                  valeurs[i - 1] + table[i - 1][w - poids[i - 1]])
    return table[n][capacite]

Complexité : O(n · W) (n objets, capacité W). C'est dit « pseudo-polynomial » : W est une valeur numérique, pas une taille de données.

Plus longue sous-chaîne commune (lettres consécutives)

Si les lettres correspondent : case = diagonale haut-gauche + 1 ; sinon 0. La réponse est le maximum de la grille.

def plus_longue_sous_chaine(a, b):
    t = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
    meilleur = 0
    for i in range(1, len(a) + 1):
        for j in range(1, len(b) + 1):
            if a[i - 1] == b[j - 1]:
                t[i][j] = t[i - 1][j - 1] + 1
                meilleur = max(meilleur, t[i][j])
    return meilleur

Plus longue sous-séquence commune (lettres dans l'ordre, pas forcément consécutives)

Si correspondance : diagonale + 1 ; sinon max(case du haut, case de gauche). Utilisée par diff et en génétique.

def plus_longue_sous_sequence(a, b):
    t = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
    for i in range(1, len(a) + 1):
        for j in range(1, len(b) + 1):
            if a[i - 1] == b[j - 1]:
                t[i][j] = t[i - 1][j - 1] + 1
            else:
                t[i][j] = max(t[i - 1][j], t[i][j - 1])
    return t[len(a)][len(b)]

Exemple : "fish" et "fosh" : sous-chaîne 2 (sh), sous-séquence 3 (fsh).

Deux styles (CLRS ch. 15)

• Descendant avec mémoïsation : récursif + cache.
• Ascendant : remplir la grille (comme ci-dessus).

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)   # O(n) au lieu de O(2^n)

Limite : la version récursive reste soumise à la limite de pile de Python (fib(5000) lève RecursionError au premier appel) ; la version ascendante n'a pas ce problème.

Problèmes classiques de CLRS : découpe de barres, produit de matrices en chaîne, plus longue sous-séquence commune, arbres de recherche optimaux.

Principe

1. Représenter chaque objet par des nombres : les caractéristiques (features). C'est l'extraction de caractéristiques.
2. Calculer la distance entre le nouvel objet et les exemples connus.
3. Prendre les k plus proches.
4. Classification : classe majoritaire. Régression : moyenne des valeurs des voisins.

Distance euclidienne : racine carrée de la somme des carrés des écarts. Grokking mentionne aussi la similarité cosinus, qui compare des directions plutôt que des tailles (utile quand les utilisateurs notent sur des échelles différentes).

Code Python 3

import math
from collections import Counter

def distance(a, b):
    return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))

def knn_classe(donnees, cible, k=3):
    voisins = sorted(donnees, key=lambda e: distance(e["point"], cible))[:k]
    return Counter(e["classe"] for e in voisins).most_common(1)[0][0]

def knn_regression(donnees, cible, k=3):
    voisins = sorted(donnees, key=lambda e: distance(e["point"], cible))[:k]
    return sum(e["valeur"] for e in voisins) / len(voisins)

def normaliser(points):
    """Ramène chaque caractéristique entre 0 et 1 (min-max)."""
    colonnes = list(zip(*points))
    mins = [min(c) for c in colonnes]
    maxs = [max(c) for c in colonnes]
    return [[(x - lo) / (hi - lo) if hi > lo else 0.0
             for x, lo, hi in zip(p, mins, maxs)] for p in points]

donnees = [
    {"point": [3, 104], "classe": "pamplemousse"},
    {"point": [2, 100], "classe": "pamplemousse"},
    {"point": [1, 81], "classe": "orange"},
    {"point": [1, 75], "classe": "orange"},
]
print(knn_classe(donnees, [2, 95], k=3))   # pamplemousse

Choisir de bonnes caractéristiques

• Elles doivent être liées à ce qu'on veut prédire et sans biais.
• Normaliser : sinon une unité en kilomètres écrase une unité en grammes.
• k : trop petit = sensible à un voisin atypique ; trop grand = on lisse trop. On le choisit en testant. Un k impair évite les égalités en classification à deux classes.

Applications citées dans Grokking

OCR (reconnaissance de caractères), filtre anti-spam (méthode bayésienne naïve), prédiction boursière (très difficile : le passé ne garantit pas l'avenir).

Limites

• Lent avec beaucoup de données (il faut comparer à tous les exemples).
• Sensible aux échelles et aux caractéristiques inutiles.
• Le choix de k est important.

Vocabulaire

Racine (tout en haut), nœud, enfant, feuille (sans enfant), hauteur (nombre de niveaux du plus long chemin racine → feuille ; c'est ce que compte la fonction hauteur ci-dessous). Attention : CLRS compte plutôt les arêtes, soit un de moins (l'arbre ci-dessous a 3 niveaux, donc une hauteur de 2 au sens de CLRS).

Arbre binaire de recherche

Chaque nœud a au plus deux enfants. Règle : tout ce qui est à gauche est plus petit, tout ce qui est à droite est plus grand.

        8
       / \
      3   10
     / \    \
    1   6    14

class Noeud:
    def __init__(self, valeur):
        self.valeur = valeur
        self.gauche = None
        self.droite = None

def inserer(racine, valeur):
    if racine is None:
        return Noeud(valeur)
    if valeur < racine.valeur:
        racine.gauche = inserer(racine.gauche, valeur)
    else:
        racine.droite = inserer(racine.droite, valeur)
    return racine

def rechercher(racine, valeur):
    if racine is None:
        return False
    if valeur == racine.valeur:
        return True
    cote = racine.gauche if valeur < racine.valeur else racine.droite
    return rechercher(cote, valeur)

def parcours_infixe(racine):
    """Renvoie les valeurs triées (gauche, racine, droite)."""
    if racine is None:
        return []
    return parcours_infixe(racine.gauche) + [racine.valeur] + parcours_infixe(racine.droite)

def hauteur(racine):
    if racine is None:
        return 0
    return 1 + max(hauteur(racine.gauche), hauteur(racine.droite))

def supprimer(racine, valeur):
    if racine is None:
        return None
    if valeur < racine.valeur:
        racine.gauche = supprimer(racine.gauche, valeur)
    elif valeur > racine.valeur:
        racine.droite = supprimer(racine.droite, valeur)
    else:
        if racine.gauche is None:
            return racine.droite
        if racine.droite is None:
            return racine.gauche
        successeur = racine.droite              # plus petit de la branche droite
        while successeur.gauche is not None:
            successeur = successeur.gauche
        racine.valeur = successeur.valeur
        racine.droite = supprimer(racine.droite, successeur.valeur)
    return racine

Complexité

Les opérations coûtent O(h), où h est la hauteur.

Si on insère des valeurs déjà triées, l'arbre dégénère en liste. Avec ce code récursif, un arbre très profond peut aussi provoquer une RecursionError.

Arbres équilibrés

• Ils se réorganisent (rotations) pour garder h = O(log n). Les plus connus : AVL et rouge-noir (CLRS ch. 13 : hauteur au plus 2 log(n+1)).
• Arbres augmentés (ch. 14) : on ajoute de l'information dans les nœuds (taille du sous-arbre) pour répondre à « quel est le k-ième plus petit ? ».
• La bibliothèque standard de Python n'a pas d'arbre de recherche équilibré ; on utilise bisect sur une liste triée ou une bibliothèque tierce.

B-arbres (CLRS ch. 18)

Nœuds larges contenant beaucoup de clés : très peu d'accès disque. Utilisés dans les bases de données et systèmes de fichiers. Sur les machines actuelles, réduire le nombre d'accès lents compte autant que le nombre d'opérations.

Tas (heap, CLRS ch. 6)

Arbre binaire presque complet où chaque parent est inférieur ou égal (tas-min) ou supérieur ou égal (tas-max) à ses enfants. Trouver l'extrême : O(1) ; insérer / retirer : O(log n). Sert à la file de priorité (Dijkstra) et à heapsort.

import heapq

tas = []
for x in (5, 1, 3):
    heapq.heappush(tas, x)
print(heapq.heappop(tas))        # 1

def tri_par_tas(liste):
    tas = list(liste)
    heapq.heapify(tas)           # O(n)
    return [heapq.heappop(tas) for _ in range(len(tas))]

Hachage ou arbre ?

• Table de hachage : recherche O(1) en moyenne, pas d'ordre de tri.
• Arbre équilibré : O(log n), ordre conservé (parcours trié, plus proche voisin, intervalles).

Idées citées dans Grokking (ch. 11 de la 1re éd., 13 dans la 2e)

• Index inversé : pour chaque mot, la liste des pages qui le contiennent (base des moteurs de recherche).
• Transformée de Fourier : décompose un signal en fréquences (compression audio, JPEG). CLRS ch. 30 : FFT en O(n log n).
• Algorithmes parallèles et MapReduce : map applique une fonction à chaque élément, reduce les combine ; utile pour répartir le travail sur plusieurs machines.
• Filtres de Bloom et HyperLogLog : structures approximatives très économes en mémoire (appartenance, comptage d'éléments distincts).
• Algorithmes SHA : empreintes de fichiers ou de mots de passe. Mise à jour sécurité : SHA-1 est considéré comme cassé (collisions publiques depuis 2017) ; préférer SHA-256 ou SHA-3. Pour stocker des mots de passe, utiliser un algorithme volontairement lent (bcrypt, scrypt, Argon2), pas un simple SHA.
• Hachage sensible à la localité : les objets similaires obtiennent des empreintes proches.
• Diffie-Hellman : accord sur une clé secrète via un canal public. Aujourd'hui, on utilise surtout ses variantes sur courbes elliptiques (ECDH).
• Programmation linéaire : optimiser un objectif sous contraintes (CLRS ch. 29, simplexe).

Chapitres de CLRS absents de Grokking

• Analyse amortie (ch. 17) : coût moyen sur une suite d'opérations (ex. ajout à un tableau dynamique).
• Union-find (ch. 21) et arbre couvrant minimal (ch. 23) : Kruskal, Prim.
• Flot maximum (ch. 26) : Ford-Fulkerson ; 4e éd. : nouveau chapitre sur les appariements dans les graphes bipartis.
• Chaînes de caractères (ch. 32) : Rabin-Karp, automates, Knuth-Morris-Pratt ; 4e éd. : tableaux de suffixes.
• Algorithmes randomisés (ch. 5), statistiques d'ordre (ch. 9 : médiane en O(n)), géométrie algorithmique (ch. 33 de la 3e éd.), arithmétique et RSA (ch. 31), multithreading (ch. 27).
• Algorithmes en ligne (4e éd.) : décisions prises sans connaître l'avenir.

Complexités à connaître par cœur

• Recherche simple O(n) · dichotomie O(log n).
• Tri par sélection / insertion O(n²) · tri fusion, heapsort O(n log n) · quicksort O(n log n) en moyenne, O(n²) au pire.
• Tableau : lecture O(1), insertion / suppression O(n). Liste chaînée : lecture O(n), insertion / suppression O(1) à une position connue.
• Table de hachage : O(1) en moyenne, O(n) au pire.
• ABR équilibré : O(log n). Tas : minimum O(1), insertion / suppression O(log n).
• BFS / DFS : O(V + E). Dijkstra (tas) : O((V + E) log V). Bellman-Ford : O(V · E). Floyd-Warshall : O(V³).
• Sac à dos (programmation dynamique) : O(n · W).
• Voyageur de commerce par force brute : O(n!).

Quel algorithme choisir ?

• Liste triée à fouiller → dichotomie (bisect).
• Trier → fonction de tri du langage (Timsort) ; comprendre fusion et quicksort pour les examens.
• Associer clé → valeur, éviter les doublons, mettre en cache → table de hachage.
• Plus court chemin sans poids → BFS ; poids positifs → Dijkstra ; poids négatifs → Bellman-Ford.
• Sous-problèmes qui se répètent → programmation dynamique.
• Optimisation NP-complète → approximation / glouton.
• Classer ou prédire par ressemblance → k plus proches voisins.
• File de priorité → tas (heapq).
• Données ordonnées avec insertions fréquentes → arbre équilibré.