Fondements théoriques de Divide and Conquer

En matière de conception d'algorithmes, on utilise souvent les techniques suivantes:

• Programmation dynamique
• La stratégie gourmande
• Diviser et conquérir

Alors que pour les deux premières méthodes, il existe des fondements théoriques bien connus, à savoir le principe de l'optimalité de Bellman et la théorie matroïde (resp. Greedoid), je n'ai pas pu trouver un tel cadre général pour les algorithmes basés sur D&C.

Tout d'abord, je suis conscient de quelque chose que nous (ou plutôt, le prof) avons introduit dans une classe de programmation fonctionnelle, appelée "squelette algorithmique", qui est apparu dans le contexte des combinateurs. À titre d'exemple, nous avons donné un tel squelette pour les algorithmes D&C comme suit:

Définition : Soit des ensembles non vides. Nous appelons les éléments des solutions , et les éléments de (c'est-à-dire les sous-ensembles de ) sont appelés problèmes . Ensuite, un squelette D&C est un quadruple , où:S P : = P ( A ) A ( P β , β , D , C$A,S$$S$ $P:=\mathfrak{P}(A)$$A$$(P_\beta, \beta, \mathcal{D}, \mathcal{C})$

• p P β ( p $P_\beta$ est un prédicat sur l'ensemble des problèmes et nous disons qu'un problème est basique si est vrai .$p$$P_\beta(p)$
• P β → $\beta$ est un mapping qui attribue une solution à chaque problème de base.$P_\beta \rightarrow S$
• P → P ( P $\mathcal{D}$ est un mapping qui divise chaque problème en un ensemble de sous-problèmes.$P \rightarrow \mathfrak{P}(P)$
• P × P ( S ) → $\mathcal{C}$ est un mappage qui joint les solutions (selon le type de "problème pivot") des sous-problèmes pour produire une solution.$P\times \mathfrak{P}(S) \rightarrow S$

Ensuite, pour un squelette donné et un problème , la fonction générique calcule une solution (au formel sens) pour :p f s : P → S $s=(P_\beta, \beta, \mathcal{D}, \mathcal{C})$$p$$f_s: P\rightarrow S$$p$

$f_s(p)= \left\{ \begin{array}{l l} \beta(p) & \quad \text{if $p$ is basic}\\ \mathcal{C}(p,f(\mathcal{D}(p))) & \quad \text{otherwise} \end{array} \right.$

où dans la deuxième ligne, nous utilisons la notation pour les sous-ensembles du domaine de codage d'un mappage .X $f(X) := \{f(x) : x\in X\}$$X$$f$

Cependant, nous n'avons pas examiné plus en détail les propriétés "structurelles" sous-jacentes des problèmes qui peuvent être formulés de cette façon (comme je l'ai dit, il s'agissait d'une classe de programmation fonctionnelle et ce n'était qu'un petit exemple). Malheureusement, je n'ai pas pu trouver de référence supplémentaire sur cette approche même. Par conséquent, je ne pense pas que les définitions ci-dessus soient tout à fait standard. Si quelqu'un reconnaît ce que j'ai déclaré ci-dessus, je serais ravi des articles connexes.

Deuxièmement, pour la stratégie gourmande, nous avons le fameux résultat qu'un problème est correctement résolu par l'algorithme gourmand général si et seulement si ses solutions constituent un matroïde pondéré. Existe-t-il des résultats similaires pour les algorithmes D & C (pas nécessairement basés sur la méthode décrite ci-dessus)?

Un traitement formel (ressemblant un peu au modèle proposé dans la question) du sujet utilisant ce qu'on appelle des pseudo-morphismes (c'est-à-dire des fonctions qui sont presque des morphismes, avec quelques pré et post-calculs effectués), ainsi que des considérations de complexité l'analyse et la mise en œuvre parallèle de tels algorithmes sont données dans:

An algebraic model for divide-and-conquer and its parallelism par Zhijing G. Mou et Paul Hudak (dans The Journal of Supercomputing , Volume 2, Issue 3, pp. 257-278, novembre 1988)

Je ne suis pas au courant de quelque chose d'aussi concret que le principe d'optimalité de Bellman pour les algorithmes Divide and Conquer. Cependant, le fondement sous-jacent de diviser pour mieux régner me semble être une définition récursive (ou inductive) de l'entrée du problème, puis un moyen de combiner des solutions au problème dans des solutions plus grandes. L'idée clé ici est de penser de manière récursive aux entrées de problèmes et de les exploiter pour des algorithmes D&C récursifs.

Prenons l'exemple de mergesort. Commençons par l'entrée, un tableau de éléments. On peut définir récursivement la structure du tableau comme suit:$n$

• Pour , le tableau est vide.$n=0$
• Pour , le tableau est un élément singleton$n=1$
• Pour , le tableau est la concaténation d'un tableau de taille (à gauche ) et de taille ( à droite )⌈ $n>1$⌊$\lceil{\frac{n}{2}}\rceil$$\lfloor{\frac{n}{2}}\rfloor$

Nous abordons ensuite l'algorithme de fusion par fusion de mappage de tri à cette structure. Les cas de base, où sont triés trivialement. Le cas récursif commence par trier récursivement où les données sont récursives , à savoir gauche et droite . Nous trouvons alors essentiellement un remplacement pour concaténer , qui finit par être fusionné . Donc, notez que nous venons de prendre la structure récursive des données et de la mapper à une solution récursive. $n\leq1$

Il est important de noter que cela ne conduit pas nécessairement à ce que vous attendez des algorithmes D&C. Nous pourrions définir la structure du tableau comme suit:

• Pour , le tableau est vide.$n=0$
• Pour , le tableau est un élément unique concaténé à un tableau de taille . n - $n>0$$n-1$

Suivre la même stratégie que nous avons utilisée pour mergesort conduit ici à un tri par insertion récursive. Donc, généralement, nous développons des définitions récursives qui impliquent plusieurs éléments récursifs, c'est-à-dire couper l'ensemble de données en deux ou tiers.

Maintenant, il y a le théorème maître pour analyser les algorithmes D&C et cela met en lumière les attentes d'efficacité pour les sous-composants d'un algorithme D&C avec une efficacité d'exécution globale particulière.