Fondamenti teorici di Divide and Conquer

Quando si tratta di progettare algoritmi, si impiegano spesso le seguenti tecniche:

• Programmazione dinamica
• La strategia golosa
• Dividere e conquistare

Mentre per i primi due metodi ci sono basi teoriche ben note, vale a dire il principio di ottimalità di Bellman e la teoria matroid (resp. Greedoid), non sono riuscito a trovare un quadro così generale per gli algoritmi basati su D&C.

In primo luogo, sono consapevole di qualcosa che noi (o meglio, il prof) abbiamo introdotto in una classe di programmazione funzionale, chiamata "scheletro algoritmico", nata nel contesto dei combinatori. A titolo di esempio, abbiamo fornito uno scheletro per gli algoritmi D&C come segue:

Definizione : Sia un set non vuoto. Chiamiamo gli elementi delle soluzioni , e gli elementi di (cioè i sottoinsiemi di ) vengono definiti problemi . Quindi, uno scheletro D & C è una 4 tupla , dove:$A,S$$S$ $P:=\mathfrak{P}(A)$$A$$(P_\beta, \beta, \mathcal{D}, \mathcal{C})$

• $P_\beta$ è un predicato sull'insieme dei problemi e diciamo che un problema è di base se valido.$p$$P_\beta(p)$
• $\beta$ è una mappatura che assegna una soluzione a ciascun problema di base.$P_\beta \rightarrow S$
• $\mathcal{D}$ è una mappatura che divide ogni problema in una serie di sottoproblemi.$P \rightarrow \mathfrak{P}(P)$
• $\mathcal{C}$ è una mappatura che unisce le soluzioni (a seconda del tipo di "problema pivot") dei sottoproblemi per produrre una soluzione.$P\times \mathfrak{P}(S) \rightarrow S$

Quindi, per un dato scheletro e un problema , la seguente funzione generica calcola una soluzione (nel formale senso) per :$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.$

dove nella seconda riga usiamo la notazione per i sottoinsiemi del codice di una mappatura .$f(X) := \{f(x) : x\in X\}$$X$$f$

Tuttavia, non abbiamo esaminato ulteriormente le proprietà "strutturali" sottostanti dei problemi che possono essere formulati in questo modo (come ho detto, era una classe di programmazione funzionale e questo era solo un piccolo esempio). Sfortunatamente, non sono riuscito a trovare ulteriori riferimenti su questo approccio. Quindi non penso che le definizioni di cui sopra siano abbastanza standard. Se qualcuno riconosce ciò che ho affermato sopra, sarei felice di articoli correlati.

In secondo luogo, per la strategia avida abbiamo il famoso risultato che un problema è correttamente risolto dall'algoritmo avido generale se e solo se le sue soluzioni costituiscono un matroid ponderato. Ci sono risultati simili per gli algoritmi D & C (non necessariamente basati sul metodo descritto sopra)?

Un trattamento formale (che ricorda in qualche modo il modello proposto nella domanda) del soggetto usando quelli che vengono chiamati pseudo-morfismi (cioè funzioni che sono quasi morfismi, con alcuni pre e post-calcoli eseguiti), nonché considerazioni di complessità l'analisi e l'implementazione parallela di tali algoritmi sono fornite in:

Un modello algebrico di divisione e conquista e il suo parallelismo di Zhijing G. Mou e Paul Hudak (in The Journal of Supercomputing , Volume 2, Issue 3, pp. 257-278, novembre 1988)

Non sono a conoscenza di qualcosa di così concreto come il principio di ottimalità di Bellman per gli algoritmi di divisione e conquista. Tuttavia, le fondamenta sottostanti di divisione e conquista mi sembrano una definizione ricorsiva (o induttiva) dell'input del problema e quindi un mezzo per combinare soluzioni al problema in soluzioni più grandi. L'intuizione chiave qui è pensare in modo ricorsivo agli input del problema e sfruttarlo negli algoritmi D&C ricorsivi.

Prendi mergesort come esempio. Cominciamo con l'input, una matrice di elementi. È possibile definire in modo ricorsivo la struttura dell'array come segue:$n$

• Per , l'array è vuoto.$n=0$
• Per , l'array è un elemento singleton$n=1$
• Per , l'array è la concatenazione di un array di dimensioni (a sinistra ) e size ( giusto )⌈ $n>1$⌊$\lceil{\frac{n}{2}}\rceil$$\lfloor{\frac{n}{2}}\rfloor$

Quindi ci avviciniamo all'algoritmo di Mergesort mappando quindi l' ordinamento su questa struttura. I casi di base, in cui sono ordinatamente ordinati. Il caso ricorsivo inizia con l' ordinamento ricorsivo in cui i dati sono ricorsivi , vale a dire sinistra e destra . Quindi troviamo essenzialmente un sostituto del concatenato , che finisce per essere unito . Quindi notate che abbiamo praticamente preso la struttura ricorsiva dei dati e li abbiamo mappati su una soluzione ricorsiva. $n\leq1$

È importante notare che ciò non porta necessariamente a ciò che ti aspetti dagli algoritmi di D&C. Potremmo definire la struttura dell'array come segue:

• Per , l'array è vuoto.$n=0$
• Per , l'array è un singolo elemento concatenato a un array di dimensioni . n - $n>0$$n-1$

Seguendo la stessa strategia che abbiamo usato per mergesort qui porta all'ordinamento ricorsivo di inserzione. Quindi, in genere sviluppiamo definizioni ricorsive che coinvolgono più elementi ricorsivi, ovvero tagliano il set di dati a metà o terzo.

Ora esiste il teorema principale per l'analisi degli algoritmi D&C e questo fa luce sulle aspettative di efficienza per i sottocomponenti di un algoritmo D&C con una particolare efficienza di runtime complessiva.