home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 May / Chip_2000-05_cd1.bin / zkuste / Perl / ActivePerl-5.6.0.613.msi / 䆊䌷䈹䈙䏵-䞅䞆䞀㡆䞃䄦䠥 / _519cba218a388b8d9ce5ee5837ac0369 < prev    next >
Text File  |  2000-03-23  |  9KB  |  222 lines
  1.  
  2. <HTML>
  3. <HEAD>
  4. <TITLE>Graph::Kruskal - Kruskal's Algorithm for Minimal Spanning Trees in Graphs</TITLE>
  5. <LINK REL="stylesheet" HREF="../../../Active.css" TYPE="text/css">
  6. <LINK REV="made" HREF="mailto:">
  7. </HEAD>
  8.  
  9. <BODY>
  10. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  11. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  12. <STRONG><P CLASS=block> Graph::Kruskal - Kruskal's Algorithm for Minimal Spanning Trees in Graphs</P></STRONG>
  13. </TD></TR>
  14. </TABLE>
  15.  
  16. <A NAME="__index__"></A>
  17. <!-- INDEX BEGIN -->
  18.  
  19. <UL>
  20.  
  21.     <LI><A HREF="#name">NAME</A></LI><LI><A HREF="#supportedplatforms">SUPPORTED PLATFORMS</A></LI>
  22.  
  23.     <LI><A HREF="#synopsis">SYNOPSIS</A></LI>
  24.     <LI><A HREF="#description">DESCRIPTION</A></LI>
  25.     <LI><A HREF="#see also">SEE ALSO</A></LI>
  26.     <LI><A HREF="#version">VERSION</A></LI>
  27.     <LI><A HREF="#author">AUTHOR</A></LI>
  28.     <LI><A HREF="#copyright">COPYRIGHT</A></LI>
  29.     <LI><A HREF="#license">LICENSE</A></LI>
  30. </UL>
  31. <!-- INDEX END -->
  32.  
  33. <HR>
  34. <P>
  35. <H1><A NAME="name">NAME</A></H1>
  36. <P>Graph::Kruskal - Kruskal's Algorithm for Minimal Spanning Trees in Graphs</P>
  37. <P>Computes the Minimal Spanning Tree of a given graph according to
  38. some cost function defined on the edges of the graph.</P>
  39. <P>
  40. <HR>
  41. <H1><A NAME="supportedplatforms">SUPPORTED PLATFORMS</A></H1>
  42. <UL>
  43. <LI>Linux</LI>
  44. <LI>Solaris</LI>
  45. <LI>Windows</LI>
  46. </UL>
  47. <HR>
  48. <H1><A NAME="synopsis">SYNOPSIS</A></H1>
  49. <UL>
  50. <LI>
  51. <A HREF="../../../lib/Pod/perlfunc.html#item_qw"><CODE>use Graph::Kruskal qw(define_vortices define_edges</CODE></A>
  52. <CODE>heapify makeheap heapsort find union kruskal example);</CODE>
  53. <P></P>
  54. <LI>
  55. <A HREF="../../../lib/Pod/perlfunc.html#item_qw"><CODE>use Graph::Kruskal qw(:all);</CODE></A>
  56. <P></P>
  57. <LI>
  58. <CODE>&define_vortices(2,3,5,7,11,13,17,19,23,29,31);</CODE>
  59. <P>Define a list of vortices (integers > 0)</P>
  60. <P></P>
  61. <LI>
  62. <CODE>&define_edges( 2,13,3, 3,13,2, 5,13,1, 3,5,2, 3,29,21 );</CODE>
  63. <P>Define (non-directed) edges on the vortices previously defined (always
  64. in triplets: ``from'' vortice, ``to'' vortice and cost of that edge)</P>
  65. <P></P>
  66. <LI>
  67. <CODE>&heapify($i,$n);</CODE>
  68. <P>Main subroutine for sorting the edges according to their costs</P>
  69. <P></P>
  70. <LI>
  71. <CODE>&makeheap($n);</CODE>
  72. <P>Routine to initialize sorting of the edges</P>
  73. <P></P>
  74. <LI>
  75. <CODE>&heapsort($n);</CODE>
  76. <P>The famous heapsort algorithm (not needed for Kruskal's algorithm as a whole
  77. but included here for the sake of completeness) for sorting the edges
  78. according to their costs</P>
  79. <P></P>
  80. <LI>
  81. <CODE>&find($i);</CODE>
  82. <P></P>
  83. <LI>
  84. <CODE>&union($i,$j);</CODE>
  85. <P>Disjoint (!) sets are stored as trees in an array in this algorithm. Each
  86. element of some set (a cell in the array) contains a pointer to (the number
  87. of) another element, up to the root element that does not point anywhere,
  88. but contains the (negative) number of elements the set contains. The number
  89. of the root element is also used as an identifier for the set.</P>
  90. <P>Example:</P>
  91. <PRE>
  92.             i  : |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |
  93.     -------------+-----+-----+-----+-----+-----+-----+-----+-----+
  94.      parent[i] : | -4  | -3  |  1  |  2  |  1  | -1  |  3  |  4  |</PRE>
  95. <P>This array contains the three sets S1, S2 and S6:</P>
  96. <PRE>
  97.                     1           2           6
  98.                    / \          |
  99.                   3   5         4
  100.                  /              |
  101.                 7               8</PRE>
  102. <P>``find'' returns the number of the root element (= the identifier of the set)
  103. of the tree in which the given element is contained:</P>
  104. <PRE>
  105.       find(a) := i  so that  a in Si</PRE>
  106. <P>It also reduces the height of that tree by changing all the pointers from
  107. the given element up to the root element to point DIRECTLY to the root
  108. element.</P>
  109. <P>Example:</P>
  110. <PRE>
  111.     find(7) returns "1" and modifies the array as follows:</PRE>
  112. <PRE>
  113.             i  : |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |
  114.     -------------+-----+-----+-----+-----+-----+-----+-----+-----+
  115.      parent[i] : | -4  | -3  |  1  |  2  |  1  | -1  |  1  |  4  |</PRE>
  116. <PRE>
  117.                     1           2           6
  118.                    /|\          |
  119.                   3 5 7         4
  120.                                 |
  121.                                 8</PRE>
  122. <P>``union'' takes the identifiers of two sets (= the numbers of their respective
  123. root elements) and merges the two sets by appending one of the two trees to
  124. the other. It always appends the SMALLER set to the LARGER one (to keep the
  125. height of the resulting tree as small as possible) and updates the number of
  126. elements contained in the resulting set which is stored in the root element's
  127. cell of the array.</P>
  128. <P>Example:</P>
  129. <PRE>
  130.     union(2,6) does the following:</PRE>
  131. <PRE>
  132.             i  : |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |
  133.     -------------+-----+-----+-----+-----+-----+-----+-----+-----+
  134.      parent[i] : | -4  | -4  |  1  |  2  |  1  |  2  |  1  |  4  |</PRE>
  135. <PRE>
  136.                     1           2
  137.                    /|\         / \
  138.                   3 5 7       4   6
  139.                               |
  140.                               8</PRE>
  141. <PRE>
  142.     complexity for O(n) "find" operations: O( G(n) n )</PRE>
  143. <PRE>
  144.     complexity for one "union" operation: O(1)</PRE>
  145. <PRE>
  146.     complexity for O(n) ( "find" + "union" ) operations: O( G(n) n )</PRE>
  147. <PRE>
  148.     where  G(n) := min{ j | F(j) >= n }</PRE>
  149. <PRE>
  150.     and    F(j) := 1            for j = 0
  151.            F(j) := 2 ^ F(j-1)   for j > 0</PRE>
  152. <PRE>
  153.     also,  G(n) <= ld n         for all n</PRE>
  154. <P></P>
  155. <LI>
  156. <CODE>&kruskal();</CODE>
  157. <P>This routine carries out the computations associated with Kruskal's algorithm.</P>
  158. <P>Returns an array of hashes (each hash containing the keys ``from'', ``to'' and
  159. ``cost'' and the corresponding values) representing the minimal spanning tree
  160. of the graph previously defined by calls to ``define_vortices'' and
  161. ``define_edges''.</P>
  162. <P>The result can also be found in @Graph::Kruskal::T.</P>
  163. <P>See the implementation of the subroutine ``example'' to see how to access this
  164. array directly (remember to fully qualify the name of this array in your
  165. program, i.e., use ``@Graph::Kruskal::T'' instead of just ``@T'', since this array
  166. is not exported - or your program will not work!)</P>
  167. <P></P>
  168. <LI>
  169. <CODE>&example();</CODE>
  170. <P>Demonstrates how to use the various subroutines in this module.</P>
  171. <P>Computes the minimal spanning tree of a sample graph.</P>
  172. <P>Just say ``use Graph::Kruskal qw(example);'' and ``&example();'' in a little
  173. Perl script to see it ``in action''.</P>
  174. <P></P></UL>
  175. <P>
  176. <HR>
  177. <H1><A NAME="description">DESCRIPTION</A></H1>
  178. <P>This algorithm computes the Minimal Spanning Tree of a given graph
  179. according to some cost function defined on the edges of that graph.</P>
  180. <P>Input: A set of vortices which constitute a graph (some cities on a map,
  181. for example), a set of edges (i.e., roads) between the vortices of the
  182. (non-directed and connected) graph (i.e., the edges can be traveled in
  183. either direction, and a path must exist between any two vortices), and
  184. the cost of each edge (for instance, the geographical distance).</P>
  185. <P>Output: A set of edges forming a spanning tree (i.e., a set of edges linking
  186. all vortices, so that a path exists between any two vortices) which is free
  187. of circles (because it's a tree) and which is minimal in terms of the cost
  188. function defined on the set of edges.</P>
  189. <P>See Aho, Hopcroft, Ullman, ``The Design and Analysis of Computer Algorithms''
  190. for more details on the algorithm.</P>
  191. <P>
  192. <HR>
  193. <H1><A NAME="see also">SEE ALSO</A></H1>
  194. <P>Math::MatrixBool(3), Math::MatrixReal(3), DFA::Kleene(3),
  195. Set::IntegerRange(3), Set::IntegerFast(3), Bit::Vector(3).</P>
  196. <P>
  197. <HR>
  198. <H1><A NAME="version">VERSION</A></H1>
  199. <P>This man page documents ``Graph::Kruskal'' version 2.0.</P>
  200. <P>
  201. <HR>
  202. <H1><A NAME="author">AUTHOR</A></H1>
  203. <P>Steffen Beyer <<A HREF="mailto:sb@sdm.de">sb@sdm.de</A>>.</P>
  204. <P>
  205. <HR>
  206. <H1><A NAME="copyright">COPYRIGHT</A></H1>
  207. <P>Copyright (c) 1995, 1996, 1997 by Steffen Beyer. All rights reserved.</P>
  208. <P>
  209. <HR>
  210. <H1><A NAME="license">LICENSE</A></H1>
  211. <P>This package is free software; you can redistribute it and/or modify
  212. it under the same terms as Perl itself.</P>
  213. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  214. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  215. <STRONG><P CLASS=block> Graph::Kruskal - Kruskal's Algorithm for Minimal Spanning Trees in Graphs</P></STRONG>
  216. </TD></TR>
  217. </TABLE>
  218.  
  219. </BODY>
  220.  
  221. </HTML>
  222.