Algoritmen en Datastructuren III Partim: Parallelle algoritmen - caagt

44 Hoofdstuk 4. Ontwerptechnieken voor parallelle algoritmen
Algoritme 4.7 Partitioneringsalgoritme
Input: A = (a1,...,an) en B = (b1,...,bm) stijgend, log 2 m en k = m/log 2 m geheel
Output: k paren deelrijen (Ai,Bi), zodat |Bi| = log 2 m, en elk element van Ai en Bi groter dan
elk element van Ai−1 en Bi−1, voor elke 1 ≤ i < k
1: Stel j0 ← 0; jk ← n
2: for i from 1 to k − 1 pardo
3: Bepaal rank(bilog 2 m : A) via de binaire zoekmethode
4: Stel ji ← rank(bilog 2 m : A)
5: for i from 0 to k − 1 pardo
6: Stel Bi ← (bilog 2 m+1,...,b (i+1)log 2 m)
7: Stel Ai ← (a ji+1,...,aji+1 )
Stelling 4.3.1. Zij C de gesorteerde rij bekomen door het mergen van de twee gesorteerde rijen
A en B, met lengte resp. n en m. Algoritme 4.7 partitioneert A en B in paren deelrijen (Ai,Bi)
zodanig dat |Bi| = Θ(log 2 m), ∑i |Ai| = n en C = (C0,C1,...), waarbij Ci de gesorteerde deelrij
is die bekomen werd door Ai en Bi te mergen. Het algoritme heeft parallelle uitvoeringstijd
T(n) = Θ(logn) en vereist W(n) = O(n+m) bewerkingen.
Bewijs: We bewijzen eerst dat elk element in de deelrijen Ai en Bi groter is dan elk element in
Ai−1 en Bi−1, voor elke 1 ≤ i < k. De twee kleinste elementen van Ai en Bi zijn resp. a j(i)+1 en
bilog 2 m+1. De tweede grootste elementen van Ai−1 en Bi−1 zijn resp. a j(i) en bilog 2 m. Aangezien
rank(bilog 2 m : A) = j(i), weten we dat a j(i) < bilog 2 m < a j(i)+1. Hieruit volgt dat bilog 2 m+1 >
bilog 2 m > a j(i) en ook dat a j(i) > bilog 2 m. M.a.w. elk van de elementen uit Ai en Bi is groter dan
elk van de elementen uit Ai−1 en Bi−1. Hieruit volgt de correctheid van het algoritme.
De complexiteitsanalyse gebeurt als volgt. Stap 1 neemt Θ(1) sequentiële tijd. De eerste parallelle
for-lus vereist Θ(logn) parallelle tijd, aangezien de binaire zoekmethode op alle gewenste
elementen in parallel uitgevoerd wordt. Het aantal bewerkingen in deze lus is gegeven
door Θ(logn×(m/logm))=O(n+m), aangezien (mlog 2 n/log 2 m) < (mlog 2 (n+m)/log 2 m) <
n+m, voor m ≥ 4. De laatste parallelle for-lus vereist Θ(1) tijd en een lineair aantal bewerkingen.
Het totale algoritme vereist dus T(n) = Θ(logn) parallelle uitvoeringstijd en W(n) = O(n+m)
bewerkingen.
Wanneer we Algoritme 4.7 toepassen op het merge-probleem (waarbij we twee rijen van gelijke
lengte n hebben), dan levert dat een stel onafhankelijke merge-deelproblemen. Dit is de essentie
van de partitioneringsstrategie.
Nu wensen we elk merge-deelprobleem op te lossen in Θ(logn) tijd, zodanig dat het totaal aantal
gebruikte bewerkingen proportioneel is met de grootte van de deelproblemen. Deze uitvoeringstijd
kunnen we als volgt bekomen.
Beschouw het merge-deelprobleem voor een willekeurig paar (Ai,Bi). Merk op dat |Bi| = log 2 n
voor alle i. Als |Ai| = O(logn), dan kunnen we (Ai,Bi) mergen in Θ(logn) sequentiële tijd door
een optimaal sequentieel algoritme te gebruiken. Anders gebruiken we Algoritme 4.7 om Ai te
partitioneren in blokken die elk O(logn) groot zijn (in dit geval speelt Ai de rol van B en Bi speelt
Algoritmen en Datastructuren III Veerle.Fack@UGent.be