DS n o 1 : Algorithmique et complexité

Transcription

1 Lycée Louis-Le-Grand, Paris 2014/2015 MPSI 4 Informatique pour tous D. Cazor, A. Troesch DS n o 1 : Algorithmique et complexité Correction du problème Alliance d entreprises (d après X PSI/PT 2006) Partie I Alliance 1. On ajoute les termes de c à la somme seulement s ils sont dans l alliance (donc sous reserve que la case correspondante de la liste a contienne True). Ainsi : def somme(c,a): """ Somme des chiffres d affaire de l alliance a """ s = 0 for i in range(len(c)): if a[i]: s += c[i] return s En notant n le nombre d entreprises, on effectue n passages dans la boucle, chaque passage étant constitué d une génération d un indice i (le suivant), d un test et éventuellement d une somme et d une affectation. On a donc au moins 2 opérations et au plus 4. Ainsi, en comptant l affectation initiale, le nombre C n d opérations effetuées vérifie : 2n+1 C n 4n+1, de quoi on déduit que C n = Θ(n). 2. Il suffit de comparer la somme obtenue à l objectif souhaité : def estreussie(c,a,obj): """ teste si une alliance est réussie; retourne True dans ce cas""" if somme(c,a) >= Obj: return True Le nombre d opérations effectué est égal, à une constante additive près liée au test, égal au nombre d opérations nécessaires pour le calcul de la somme, d où la complexité linéaire. 3. On vérifie tout d abord que l alliance est réussie (première condition pour qu elle soit stable). Ensuite, on vérifie qu en enlevant une quelconque des entreprises de l alliance, on obtient une alliance ratée : pour cela, on énumère les entreprises de l alliance, et on retranche leur chiffre d affaire à la somme obtenue pour l alliance complète : si pour l une des entreprises, on reste au dessus de Obj, l alliance n est pas stable, sinon elle est stable. On n utilise pas la fonction estreussie, car on a besoin de la valeur de la somme des chiffres d affaire de l alliance : l utilisation de cette fonction, nous ferait calculer une première fois cette somme, mais sans nous en donner accès, nous obligeant alors à la calculer une deuxième fois. def eststable(c,a,obj): """ teste si une alliance est stable; retourne True dans ce cas""" s = somme(c,a) # on revient à la somme plutôt qu à # estreussie, car sinon, on doit la calculer # plusieurs fois if s >= Obj: for i in range(len(c)): if a[i] and s - c[i] >= Obj: # on a trouvé une alliance plus petite 1

2 # provoque la sortie de la fonction return True Le temps d exécution est encore linéaire : on calcule la somme en temps linéaire, puis on exécute ou non une séquence également linéaire (une boucle constituée de n itérations d une séquence constituée d un nombre non nul et borné d opérations). Une somme de Θ(n) étant encore Θ(n), on a bien un temps d exécution linéaire en n 4. On construit une alliance réussie en sommant les chiffres d affaire les plus gros. En commençant par les plus gros chiffres d affaire, on s arrête dès qu on dépasse l objectif. On obtient ainsi une alliance réussie constituée d un nombre k d entreprises. Il s agit plus précisément des k entreprises ayant les plus gros chiffres d affaire. Les k 1 entreprises de chiffre d affaire maximal ne réalisent pas l objectif par construction. Ainsi, en selectionnant k 1 entreprises de chiffres d affaire éventuellement inférieurs, on ne peut pas non plus remplir l objectif. On en déduit que toute alliance réussie possède au moins k entreprises. On en déduit d une part que l alliance construite est stable, et d autre part qu elle est minimale pour le nombre d entreprises. Cela justifie la validité de l algorithme donné. def alliancemin(c,obj): """ donne une alliance stable minimale""" a = [False for i in range(len(c))] s = 0 i = len(c)-1 while s < Obj and i >=0: s += c[i] a[i] = True # on ajoute l entreprise i à l alliance i -= 1 if s >= Obj: return a Partie II Calcul des alliances stables 1. Il s agit d ajouter 1 à la représentation binaire. D un point de vue purement algorithmique, cela revient à remplacer la dernière séquence dans la représentation binaire par (les 1 étant les True, et les 0 les False). On remplace donc, en partant des chiffres de plus petit poids (correspondant aux petits indices), les 1 par des 0 (donc les True par des False), jusqu à ce qu on rencontre un 0 (False), qu on remplace par 1 (True). Cela donne : def suivantede(a): """ Donne l alliance suivante """ i = len(a)-1 while i >=0 and a[i]: a[i] = False i -=1 if i < 0: # cas où il n y a pas d alliance suivante a[i] =True return a Sauf éventuellement à la toute dernière opération, l entier i est toujours positif (sa négativité déclanche la sortie de boucle) et décroît strictement d une itération à l autre. Ainsi, i est un variant de boucle assurant la terminaison de cette fonction (on peut prendre i+1 si on veut éviter la valeur négative possible au moment de la sortie de boucle). Par ailleurs, i diminue strictement de n 1 à 1, à moins qu on ne sorte de la boucle avant cela. Ainsi, il y a au plus n itérations, constituées d un nombre borné d opérations. Ainsi, le temps d exécution est au plus linéaire. 2

3 Suivant la valeur de a, on peut avoir un temps d éxécution meilleur que linéaire (si la dernière séquence de 1 est courte). 2. Il s agit simplement de créer une liste constituée des indices des entreprises de l alliance. Pour cela, on part de la liste l vide, et on parcourt la liste a : on ajoute alors à l les indices des entreprises validées par la liste a : def convertitboolliste(a): """ convertit une alliance booléenne en liste d entreprises """ l=[] for i in range(len(a)): if a[i]: # On ajoute i seulement si a[i]=true l.append(i) return(l) 3. Comme suggéré en début de partie, on ne cherche pas ici à être très subtil. On énumère les alliances les unes après les autres, grâce à suivantede, et on teste à chaque fois si elles sont stables ou non : def ToutesAlliancesStables(c,Obj): """ Fournit la liste de toutes les alliances stables """ listestable = [] a = [False for i in range(len(c))] # initialisation de a avec l alliance représentée par 0 # l alliance vide ne peut pas être réussie puisque Obj>0, on passe # directement à la suivante a = suivantede(a) while a!= False: # a = False si suivantede renvoie False, donc # s il n y a pas d alliance suivante. if eststable(c,a,obj): listestable.append(convertitboolliste(a)) a = suivantede(a) return listestable Le nombre d alliances (donc le nombre d itération) est 2 n. Chaque itération se fait en temps linéaire (test de stabilité linéaire et calcul de l alliance suivante au plus linéaire). Ainsi, cette fonction a une complexité en Θ(n2 n ), donc Ω(2 n ) et O(α n ) pour tout α > 2. On a donc une complexité exponentielle. Autant dire que cet algorithme est mauvais, et qu on a tout intérêt à trouver mieux! Partie III Optimisation On définit l ordre binaire sur les tableaux de booléen par a a si et seulement si bin(a) < bin(a ). Dans la partie II, on a déterminé les alliances stables, en les rangeant par ordre croissant pour l ordre. Dans cette partie, on optimise cette recherche en supposant que les entreprises sont classées par chiffres d affaires croissants. On suppose donc c[0] c[1] c[n 1]. Pour réaliser cette recherche rapide, on construit le tableau t vérifiant t[i] = c[0]+c[1]+ +c[i], pour 0 i < n. 1. On ne reprend pas le calcul de la somme du début pour chaque coefficient, mais on part de la somme précédente (sinon, on obtient un temps d exécution quadratique et non linéaire). On obtient : def cumuls(c): """ Calcul du tableau des cumuls """ t = [c[0]] for i in range(1,len(c)): t.append(t[i-1] + c[i]) return t Pour trouver a, première alliance stable dans l ordre binaire, on cherche l indice k minimum tel que t[k] Obj. L entreprise k est dans l alliance a, et on doit compléter cette alliance avec des entreprises de chiffres d affaires plus petits pour dépasser la somme restante Obj = Obj c[k]. Pour compléter cette alliance partielle {k}, on cherche le 3

4 plus petit k tel que t[k ] Obj. On sait qu il existe puisque t[k] Obj. Donc k est aussi dans l alliance a et on recommence à nouveau pour dépasser la somme restante Obj = Obj c[k ]. en complétant l alliance partielle {k,k},... jusqu au moment où la somme restante devient négative ou nulle. 2. (a) On traduit l algorithme ci-dessus en pseudo-code : Algorithme 1 : Recherche Première Alliance Entrée : c : chiffres d affaire, t : liste des cumuls, Obj : objectif Sortie : Première alliance stable dans l ordre binaire Initialiser a (alliance vide) ; NouvelObjectif Obj (initialisation de l objectif initial) ; tant que NouvelObjectif > 0 faire k recherchek(t,nouvelobjectif) ; si k 1 (cas ou l objectif peut être atteint) alors a[k] True (Ajout de l entreprise trouvée à l alliance) ; NouvelObjectif NouvelObjectif - c[k] (Actualisation de l objectif restant à réaliser) sinon renvoyer False et sortir fin si fin tant que renvoyer a (b) Terminaison : Quitte à multiplier tous les chiffres d affaire par une constante assez grande (ce qui revient à faire un changement d unité), on peut considérer qu ils sont tous au moins égaux à 1 (il vaut mieux pour l entreprise!) Alors, l entier NouvelObjectif est strictement décroissant d une itération à l autre, et positif tant qu on continue. Il s agit donc d un variant de boucle assurant la terminaison. On peut aussi prendre comme variant de boucle le nombre d entreprises non selectionnées dans l alliance partielle. Correction : on part de l observation suivante : la valeur k trouvée lors de la première étape est telle que toute alliance réussie possède au moins une part d indice supérieur ou égal à k. En effet, si ce n est pas le cas, toutes les parts sont d indice strictement inférieur à k, donc la somme des chiffres d affaires des entreprises considérées est inférieure ou égale à t[k 1]. Comme t[k 1] < Obj par définition de k, l alliance ne peut pas être réussie. Par ailleurs, il existe une alliance réussie dont la plus grande part est c[k] (l alliance des entreprises 0 à k). Comme de toute alliance réussie on peut extraire une alliance stable (on retire des entreprises tant qu on peut le faire sans perdre la réussite, quand on ne peut plus, on a obtenu une alliance stable), cela signifie qu il existe une alliance stable dont la plus grande part est c[k]. De ces deux observations découle le fait que l alliance stable minimale contient la part k. Une fois cette part k imposée, il faut choisir les autres entreprises de façon minimale, dévant dépasser l objectif restant, à savoir Obj c[k]. Comme cela peut se faire uniquement avec les entreprises 0 à k 1, cela revient à itérer l argument précédent avec ce nouvel objectif. Une récurrence basé sur ces observations montre qu on a alors un invariant de boucle : «À l issue du i-ième passage dans la boucle, s il a lieu, a fournit la liste des i entreprises de plus grand poids dans l alliance stable minimale.» En sortant de la dernière boucle, si k 1, alors NouvelObjectif < 0, ce qui signifie que l objectif est réalisé. Comme il ne l était pas à l étape précédente, et que l entreprise qu on ajoute lors de la dernière étape a un chiffre d affaires inférieur au chiffre d affaire que celles qu on a déjà selectionnées, l alliance obtenue est stable, et d après l invariant de boucle, elle est contituée des plus grandes parts de l alliance stable minimale : il s agit nécessairement de l alliance stable minimale. La cas où k = 1 est le cas où la somme de tous les chiffres d affaires est inférieur à l objectif à réaliser : il n y a pas d alliance réussie, donc pas d alliance stable. Complexité : À chaque passage dans la boucle, le nombre d entreprises non selectionnées diminue srictement. Ainsi, le nombre de passages dans la boucle est au plus égal à n. La complexité obtenue dépendra de l implémentation de recherchek. Une implémentation minimaliste donne une complexité linéaire pour cette recherche (on parcout t jusqu à dépasser la valeur souhaitée). Dans ce cas, la complexité globale est en O(n 2 ), donc on a un algorithme au plus quadratique. 4

5 On peut cependant remarquer que les chiffres d affaire étant positifs, t est un tableau trié (par ordre croissant). Ainsi, la valeur de k peut se trouver par recherche dichotomique, donc avec une complexité en O(ln(n)). De la sorte, la complexité de l algorithme obtenu est en O(nln(n)). (c) À la lumière de l explication précédente, nous effectuons une recherche dichotomique dans le tableau t : def recherchek(t,obj): """ recherche dichotomique du cumul dépassant l objectif """ a = 0 b = len(t)-1 if t[b]< Obj: return -1 if t[a] >= Obj: return a while b-a > 1: c = (a + b) // 2 if t[c]>= Obj: b = c a = c return b La fonction recherchepremierealliance(c,t,obj) est alors obtenue en transcrivant en Python le pseudocode ci-dessus : def recherchepremierealliance(c,t,obj): """ Recherche de la première alliance stable dans l ordre binaire """ a = [False for i in range(len(c))] NouvelObj = Obj while NouvelObj > 0: k = recherchek(t,nouvelobj) if k!= -1: a[k] = True NouvelObj -= c[k] return a, Obj - NouvelObj On renvoie aussi l objectif réel réalisé par cette alliance, pour des raisons techniques (nous en avons besoin par la suite, pour éviter d avoir à recalculer ces objectifs à chaque fois, ce qui augmenterait le temps de calcul). 3. Soit a une alliance stable pour l objectif Obj, et i l indice minimal tel que a[i] = True. Soit l le plus grand entier tel que a[i] = a[i+1] = = a[i+l] = True. si i + l = n 1, l alliance est contituée des l + 1 entreprises de poids maximal. Les alliances supérieures dans l ordre binaire sont obtenues de celles-ci en ajoutant des entreprises de poids inférieur. Mais alors, ces alliances ne peuvent pas être stables (puisque sans ces entreprises de poids inférieurs, l alliance était déjà réussie). Donc il n existe pas d entreprise stable suivante. Soit a l alliance initiale. Si i+l < n 1 pour la même raison que ci-dessus, toute alliance contituée des mêmes entreprises les plus grosses (au delà strictement du rang i+l) sera obtenue en ajoutant des parts plus petites, donc ne sera pas stable. Ainsi, s il en existe une, une alliance stable strictement supérieure à a nécessite une modification de la selection des entreprises de rang > i + l + 1 de sorte à obtenir une poids plus fort pour l ensemble de ces entreprises. La plus petite modification qu on puisse faire est simplement d ajouter l entreprise c[i + l + 1]. Toute autre modification donnera une alliance plus grande dans l ordre binaire. Il suffit donc de justifier qu il existe bien une entreprise stable obtenue de la sorte. 5

6 Or, si on remplace dans l alliance initiale l entreprise i + l par l entreprise i + l + 1. Appelons a l alliance initiale, et a l alliance obtenue. Comme c[i+l+1] c[i+l], l alliance a est encore réussie. En revanche, en enlevant la part c[i+l+1] de a, l alliance n est plus réussie (car cela revient à enlever la part c[i+l] à a, et on sait que a est stable). C est encore pire si on enlève une part c[k], k > i+l+1. Il existe donc une alliance stable, extraite de a, contenant l entreprise i+l+1, et toutes les entreprises plus grosses. Ainsi, il existe une alliance stable supérieure à l alliance a. On en déduit qu il existe une alliance minimale supérieure à a, et que celle-ci contient l entreprise i+l+1, ainsi que toutes celles au-delà qui étaient déjà dans a. Pour trouver les autres entreprises, on complète de la même manière qu en 2(c), avec les mêmes justifications. 4. On obtient donc le code suivant : def StableSuivanteDe(a,c,t,Obj,ObjRealise): """ Recherche de l entreprise stable suivant a """ # ObjRealise est l objectif effectif de l alliance a i = 0 while not a[i]: i+=1 k = i while k < len(c) and a[k]: # On retire les entreprises de la première séquence de la liste # On retire aussi leur chiffre d affaire de l objectif réalisé a[k]= False ObjRealise -= c[k] k += 1 if k == len(c): # On ajoute l entreprise i+l+1=k, ainsi que le chiffre d affaire a[k] = True ObjRealise += c[k] # A ce stade, on a une alliance partielle contenant l entreprise # i+l+1, et les plus grosses. On la complète à la manière # de la fonction précédente NouvelObj=Obj-ObjRealise while NouvelObj > 0: k = recherchek(t,nouvelobj) a[k] = True NouvelObj -= c[k] return a, Obj - NouvelObj 5. La fin est une formalité : on passe d une alliance stable à la suivante grâce à la fonction précédente. La fonction 2(c) nous donne le point de départ. L arrêt est obtenu lorsqu il n y a pas de suivante, donc lorsque la fonction de la question 4 retourne False. def ToutesAlliancesStables2(c,Obj): """ Recherche de toutes les alliances stables """ t = cumuls(c) a, ObjRealise = recherchepremierealliance(c,t,obj) li = [] while a!= False: li.append(convertitboolliste(a)) a, ObjRealise = StableSuivanteDe(a,c,t,Obj,ObjRealise) 6