Question

Sometimes we want light spanning trees with certain special properties. Here’s an example.

Input: Undirected graph G=(V,E) ; edge weights we; subset of vertices $\mathbf{U}\mathbf{\subset }\mathbf{V}$

Output: The lightest spanning tree in which the nodes of U are leaves (there might be other leaves in this tree as well).

(The answer isn’t necessarily a minimum spanning tree.)

Give an algorithm for this problem which runs in $\mathbf{O}\left(\left|E\right|\log \left|V\right|\right)$ time. (Hint: When you remove nodes Ufrom the optimal solution, what is left?)

Short answer

Working with lightest spanning tree in the nodes of and to get answer which is necessary minimum spanning tree base on the given formula$\mathrm{O}\left(\left|\mathrm{E}\right|\log \left|\mathrm{V}\right|\right)$.

Step-by-step solution

Step 1: Light-spanning tree algorithm

Both lemma1 as well as feature 1 are being used in the light spanning tree algorithm..

Lemma1:• "If indeed the network has vertices "U" as leaves, a lightest spanning trees containing vertices "U" for leaves isn't really possible." G” There isn't a minimal spanning tree."

Property 1:

• “"Minimal level spanning tree is constructed on the network if eagerly select and add edges while all vertices "U" become leaves."G” It is said to be the lightest spreading tree”.

Step 2: Algorithm

Procedure for spreading light across a tree (G,w,E)

Input: Linear graphs G = (V,E) ; edge weights ${\mathrm{w}}_{\mathrm{e}};\mathrm{U}\mathrm{C}\mathrm{V}{\mathrm{W}}_{\mathrm{e}};\mathrm{U}\subset \mathrm{V}$

Output: The tree with the shortest span

A graph $\tilde{G}=(\tilde{V},\tilde{E})$ such that

$\tilde{\mathrm{V}}=\mathrm{V}-\mathrm{U}$

$\tilde{\mathrm{E}}=\{\left(\mathrm{u},\mathrm{v}\right):\mathrm{u},\mathrm{v}\in \mathrm{V}-\mathrm{U}\wedge \left(\mathrm{u},\mathrm{v}\right)\in \}$

To go and get MST , use Kruskal's method$\widetilde{\left(\mathrm{G}\right)}=\tilde{\mathrm{T}}$:

/Make sure the tree is still alive. does not exist

if $\tilde{\mathrm{T}}$does not exist:

It is impossible to plant the lightest spanning tree.Consider an Edge set $\tilde{\mathrm{E}}$such that:

$\forall \left(\mathrm{u},\mathrm{v}\right)\in \tilde{\mathrm{E}}:\mathrm{u}\in \mathrm{U}\wedge \mathrm{v}\notin \mathrm{U}$

When sorting the edge, loop on until vertex "U" is reached.

//weights for each : $u\in U$

//refer textbook for makeset()

Filter all edge weights using makeset(u). $\tilde{\mathrm{E}}$by ${\tilde{w}}_e$

/Continue in this loop until enough edges' weights are rising in sequence.u,v$\in \mathrm{E}$ in increasing order of weight:

/Verify that find(u) isn't really same as,

// find (v)

if $\mathrm{find}\left(\mathrm{u}\right)\ne \mathrm{find}\left(\mathrm{v}\right))$:

//insert the edges inside tree

add edge u, v to $\tilde{T}$

/To combine the u and v , call function union on u , v .

// v

union( u,v )

//Return the tree

return$\tilde{\mathrm{T}}$

Singleton collection Holding Parameter

makeset()definition:

makeset() generates singleton collections holding all value of the parameter argument. Its meaning of makeset may be found on page 132 of something like the textbook () .

union()definition:

To join the sets involving two outcomes for passing arguments, utilize union(). This definition term union may be stated on page 133 of both the textbook () .

find()definition:

find() is often used to explore each combination to nodes on until necessary sets are found. The definition of discover may be found on page 132 of the textbook() .

Explanation:

While in thinnest spanning tree method described previously,• Construct the graph $\tilde{\mathrm{G}}$with the vertex $\tilde{\mathrm{V}}$ and edge $\tilde{\mathrm{E}}$.

• Obtain the minimal spanning tree for just a graph using the Kruskal's approach.$\tilde{\mathrm{G}}$.

• Where there is no minimal spanning tree, then thinnest spanning tree can indeed be built..

• Generate any edge collection inside the name of the smallest spanning tree if one exists $\tilde{\mathrm{E}}$.

• Using for each read all the vertices “U”.

• Using the function make set() sort the weight of the edges.

Using for loop read the order of weight in increasing order.

• Using if condition, check whether find of vertex“u” is not equal to find of vertex“v”.

• If the above condition is true, then add edges to the tree.

• Invoke the union() function by passing the vertex u and v.

• Otherwise, exit the loop.

Finally, return the constructed tree $\tilde{\mathrm{T}}$.

Conclusion

• Other than the edge set “ $\overline{\mathrm{E}}$”, the remaining complexity is similar to Kruskal’s algorithm. That is, the running time is $\mathrm{O}\left(\left|\mathrm{E}\right|\log \left|\mathrm{v}\right|\right)$.

• Then, construct the set “U”.

o For edge weight “e = (u,v)”. If find(u) is not equal to find(v) . Then, the edge “$\overline{\mathrm{E}}$” takes the running time of role="math" localid="1658922590785" $\mathrm{O}\left(\left|\mathrm{E}\right|\log \left|\mathrm{U}\right|\right)$.

o When deleting the node “U” from the optimal solution, then, the algorithm is still bounded the running time of $\mathrm{O}\left(\left|\mathrm{E}\right|\log \left|\mathrm{V}\right|\right)$.

Therefore, the total running time for light spanning tree algorithm is $\mathrm{O}\left(\left|\mathrm{E}\right|\log \left|\mathrm{V}\right|\right)$.