filter-kruskal mst...

Filter-Kruskal MST AlgorithmVitaly Osipov, Peter Sanders, Johannes Singler

Universitat Karlsruhe (TH)

Vitaly Osipov, Johannes Singler, Peter Sanders Filter-Kruskal MST Algorithm

Motivation

What is the best (practical) algorithm for Minimum Spanning Trees?

◮ Kruskal?


Motivation


◮ Kruskal? for very sparse graphs


Motivation


◮ Kruskal? for very sparse graphs◮ Jarnık–Prim?


Motivation


◮ Kruskal? for very sparse graphs◮ Jarnık–Prim? else


Motivation


◮ Kruskal? for very sparse graphs◮ Jarnık–Prim? else◮ Karger–Klein–Tarjan, Chazelle, Pettie–Ramachandran,. . . ?


Motivation


◮ Kruskal? for very sparse graphs◮ Jarnık–Prim? else◮ Karger–Klein–Tarjan, Chazelle, Pettie–Ramachandran,. . . ?

too complicated


Kruskal’s Algorithm

Procedure kruskal(E ,T : Sequence of Edge,P : UnionFind)sort E by increasing edge weightforeach {u, v} ∈ E do

if u and v are in different components of P thenadd edge {u, v} to Tjoin the partitions of u and v in P


Kruskal’s Algorithm

Procedure kruskal(E ,T : Sequence of Edge,P : UnionFind)sort E by increasing edge weightforeach {u, v} ∈ E do

if u and v are in different components of P thenadd edge {u, v} to Tjoin the partitions of u and v in P

◮ Time O ((n + m) log m)


Quick-Kruskal

Procedure qKruskal(E ,T : Sequence of Edge,P : UnionFind)if m ≤ kruskalThreshold(n, |E |, |T |)

then kruskal(E ,T ,P)else

pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉qKruskal(E≤,T ,P)qKruskal(E>,T ,P)

p


Quick-Kruskal

Procedure qKruskal(E ,T : Sequence of Edge,P : UnionFind)if m ≤ kruskalThreshold(n, |E |, |T |)


pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉qKruskal(E≤,T ,P)qKruskal(E>,T ,P)

◮ O(

m + n log2 n)

– random graphs, random edge weights

◮ Θ((n + m) log m) if there is any heavy MST edge,e.g., Lollipop graph with random edge weights


Filter-Kruskal

Procedure filterKruskal(E ,T : Sequence of Edge,P : UnionFind)if m ≤ kruskalThreshold(n, |E |, |T |)


pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉filterKruskal(E≤,T ,P)E>:= filter(E>,P)filterKruskal(E>,T ,P)

Function filter(E)return 〈{u, v} ∈ E : u, v are in different components of P〉

p


Filter-Kruskal



pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉filterKruskal(E≤,T ,P)E>:= filter(E>,P)filterKruskal(E>,T ,P)


◮ For random edge weights

Time - O(m + n log n logmn)


Filter-Kruskal , Parallelization


then kruskal(E ,T ,P) parallelelse

pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉 parallelfilterKruskal(E≤,T ,P)E>:= filter(E>,P) parallelfilterKruskal(E>,T ,P)





Filter-Kruskal , ParallelizationUse STL algorithms from libstdc++ parallel mode


then kruskal(E ,T ,P) sortelse

pick a pivot p ∈ EE≤:= 〈e ∈ E : e ≤ p〉; E>:= 〈e ∈ E : e > p〉 partitionfilterKruskal(E≤,T ,P)E>:= filter(E>,P) remove iffilterKruskal(E>,T ,P)





Getting rid of the log m/n? E.g., random graphs

2

2.5

3

3.5

4

4.5

32 64 27 28 29 210211212213214215216217218219220221222

com

paris

ons

/ edg

es m

= n

log(

n)

number of nodes n

filterKruskallog(log(x))


Filter-Kruskal+

Function filter+(E ,T ,P)E ′:= 〈{u, v} ∈ E : u, v are in different components of P〉T ′:= 〈{u, v} ∈ E ′ : u or v have degree one in comp. graph 〉T := T ∪ T ′

return E ′ \ T ′

p


Linear Time? E.g., random graphs

5

10

15

20

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

num

ber

of c

ompa

rison

s / n

number of nodes n

m=n m=2n m=4n


Running Time: Random graph with 216 nodes

10

100

1000

1 4 16 64 256 1024

time

/ m [n

s]Kruskal

qKruskalKruskal8

filterKruskal+

filterKruskalfilterKruskal8

qJPpJP


Conversion time, random graphs

10

100

1000

2 4 8 16 32 64 27 28 29 210211212213214215216

time

/ m [n

s]

number of edges m / number of nodes n

n=216, Edges -> Adj. Arrayn=222, Edges -> Adj. Arrayn=216, Adj. Array -> Edgesn=222, Adj. Array -> Edges


Conclusions

filterKruskal improves on Kruskal and Jarnık–Prim◮ very simple◮ often faster◮ parallelizable◮ needs only edge sequence

Todo: More real world inputs, tight analysis,. . .

Open Problem: What about filterKruskal+◮ provably linear time?◮ scalable parallelization? Sequential component O

(

n0.6)

?◮ more efficient implementation


Thank you!


Random graph with 210 nodes

10

100

1 2 4 8 16 32 64 128 256

time

/ m [n

s]

KruskalqKruskalKruskal8filterKruskal+filterKruskalfilterKruskal8qJPpJP


Random graph with 222 nodes

100

1000

1 2 4 8 16

time

/ m [n

s]




Random graph, n = 216, anti-Prim weights

10

100

1000

10000

100000

1 2 4 8 16 32 64 128 256

time

/ m [n

s]


KruskalqKruskalKruskal8

qJPpJP

filterKruskal


Random geometric graph with 216 nodes

10

100

4 8 16 32 64 128 256

time

/ m [n

s]




Lollipop graph with 210 nodes

10

100

1000

1 2 4 8 16 32 64 128

time

/ m [n

s]


KruskalqKruskalKruskal8

filterKruskal+

filterKruskalfilterKruskal8

qJPpJP



10

100

1 4 16 64 256 1024

time

/ m [n

s]





100

1000

1 2 4 8 16

time

/ m [n

s]




Image Segmentation Application

4 8 16tim

e / m

[ns]

m / nKruskal

qKruskalKruskal8

filterKruskal+

10

100

4 8 16

m / nfilterKruskal

filterKruskal8qJPpJP


filter-kruskal mst...

Documents