Special cases of the minimum spanning tree problem under explorable edge and vertex uncertainty

This article studies the Minimum Spanning Tree Problem under Explorable Uncertainty as well as a related vertex uncertainty version of the problem. We particularly consider special instance types, including cactus graphs, for which we provide randomized algorithms. We introduce the problem of finding a minimum weight spanning star under uncertainty for which we show that no algorithm can achieve constant competitive ratio.


Introduction
Many real world problems do not allow to work with precise data as parts of the input are uncertain or only known approximately.Different approaches to deal with uncertainty include stochastic optimization where the input data is known to follow a specific probability distribution, robust optimization which aims to find good solutions for all possible inputs and explorable uncertainty.In the latter setting, it is possible to obtain more precise or even exact data by making queries.However, any query causes exploration cost.In an applied scenario this might be time, money or other ressources which are needed for further measurements.In this paper, we consider the Minimum Spanning Tree Problem under Explorable Uncertainty (MST-U) where the goal is to find a minimum spanning tree (MST) in an edge weighted graph where the weights are initially not known but can be revealed upon request.In an instance of MST-U, each edge is equipped with an uncertainty set and a query cost.The uncertainty set, usually an interval, is guaranteed to contain the edge's weight.An edge query reveals the edge's true weight.The goal is to find a set Q of queries of minimum cost which allows to find a minimum spanning tree with certainty, i.e. given the weights of all edges in Q, there exists an edge set T such that T is a minimum spanning tree for all possible weights with respect to the remaining uncertainty sets.The queries may be chosen adaptively which means that we are allowed to choose the next update based on the previous outcomes of edge queries.Note that while MST-U requires the specification of an edge set which corresponds to an MST, it is not necessary to compute the MST weight.

Related work
The first work on problems where parts of the input are uncertain and can be queried is due to Kahan (see [10]) who studied the problem of finding the maximum, the median and the minimum of a set of real values, each of which is known to lie in a given interval.Since then, explorable uncertainty has been considered for different combinatorial problems, e.g.shortest paths (see [6]), scheduling (see [2]) and the Knapsack Problem (see [9]).Erlebach et al. were the first to introduce the Minimum Spanning Tree Problem under Explorable Uncertainty in [5].They showed that without restrictions made on the uncertainty sets, no algorithm can achieve constant competitive ratio.This is why subsequently it is assumed that uncertainty sets are either singletons or do not contain neither their supremum nor their infimum (e.g.open intervals).[5] also presented the deterministic algorithm U-RED for MST-U with uniform query costs which achieves competitive ratio 2 and proved that no deterministic algorithm can have a smaller competitive ratio.Moreover, they introduced a different version of this problem, the Minimum Spanning Tree Problem under Vertex Uncertainty (V-MST-U) where vertices are points with uncertain locations in the plane and the edge weights correspond to the distances between the respective end vertices.They showed that U-RED can be adapted to work for the vertex uncertainty setting as well if uncertainty sets are (topologically) open.An important question left open was the effect of randomization in the setting of MST-U.This question was subsequently answered by Megow et al. in [11] where they provided the randomized algorithm Random with competitive ratio 1 + 1 √ 2 .The best known bound for the performance of randomized algorithms is 1.5 which holds true even for triangles and was observed by Erlebach and Hoffmann in [4].[11] transformed their randomized algorithm into the deterministic algorithm Balance which achieves a competitive ratio of 2 on instances with general query cost.[11] also considered the problem of finding the weight of an MST under uncertainty, the problem of finding an α-approximate MST under uncertainty as well as a version of MST-U where queries return subintervals instead of the precise edge weights.Test results for MST-U are provided by Focke et al. in [7].In [3], Erlebach and Hoffmann deal with the verification problem for MST-U, i.e. the problem of computing an optimal query set if the uncertainty sets as well as the exact edge weights are given.They show that the verification problem for MST-U is solvable in polynomial time while the verification problem for the vertex uncertainty problem V-MST-U is NP-hard.

Our Contribution
One of the main difficulties in solving MST-U stems from dealing with edges that are part of several cycles.Thus, it is a natural question to consider the special case of cactus graphs where every edge belongs to at most one cycle.However, the algorithm Random presented in [11] reaches its worst case competitive ratio of 1 + 1 √ 2 ≈ 1.71 even for instances where the input graph is a cycle.We introduce an algorithm which achieves competitive ratio 1.5 on instances with cactus graphs.V-MST-U on the contrary, has only been considered in the setting of deterministic algorithms so far.We prove that there exists no randomized algorithm for V-MST-U with a competitive ratio better than 2.5 even if the input graph is a cycle.Unfortunately, structural differences between the edge uncertainty setting and the vertex uncertainty setting impede the straight forward adaption of Random to the vertex uncertainty setting.Instead, we consider the special case of cactus-like instances where no two cycles share a non-trivial vertex and introduce the algorithm V-Random C for which we prove a competitive ratio of at most 2.5.While deterministic and randomized algorithms with reasonable performance guarantee exist for MST-U, this is not necessarily the case when aiming for more restricted graph classes than spanning trees.We demonstrate this by introducing the Minimum Spanning Star Problem under Explorable Uncertainty (MSS-U).MSS-U is defined analogously to MST-U except that we want to identify a spanning star of minimum weight rather than a general spanning tree.For MSS-U we derive a negative result with respect to competitive analysis, i.e we show that no algorithm for MSS-U can achieve constant competitive ratio.The remainder of this paper is organized as follows: In Section 2 we provide the precise definition of MST-U and further basic definitions and concepts used throughout the rest of the paper.Section 3 deals with a randomized algorithm for MST-U on cactus graphs.In Section 4 we prove a lower bound for the performance of randomized algorithms for V-MST-U and introduce an optimal randomized algorithm for V-MST-U on cactus-like graphs.In Section 5 we study the Minimum Spanning Star Problem under Explorable Uncertainty.We conclude with a brief summary and some open questions in Section 6.

Preliminaries
In this section we will introduce definitions, notation and structural results used throughout this paper.

Problem definition MST-U and notation
Definition An (edge-)uncertainty graph is a tuple G = (G, (A e ) e ) where G = (V, E) is an undirected, connected graph and for each edge e ∈ E, A e ⊂ R is either a singleton set or a set which neither contains its infimum nor its supremum.The sets A e with e ∈ E are called uncertainty sets.
An instance of the Minimum Spanning Tree Problem under Explorable Uncertainty (MST-U) is specified in terms of an uncertainty graph G = (G, (A e ) e ) as well as an a priori unknown edge weight w e ∈ A e and a query cost q e > 0 for each e ∈ E. We denote by n = |V | the number of vertices and by m = |E| the number of edges of G.If A e contains a single element only we say that A e is trivial.An edge e is trivial if A e is trivial.For an edge e ∈ E, we denote by L e := inf A e the infimum and by U e := sup A e the supremum of the uncertainty set.We will also refer to L e and U e as the lower and the upper limit of A e (or of e) respectively.We can query an edge e to determine its weight w e .If we query e, the set A e is updated to a singleton set containing only w e .The cost of querying an edge e is q e > 0. The goal is to find an edge set T of a minimum spanning tree (MST) in G with respect to edge weights w e while minimizing the total cost of queries needed to find T .More precisely, a feasible query set is defined as follows: Definition Given an uncertainty graph G with graph G = (V, E) and uncertainty sets A e , e ∈ E, as well as edge weights w e ∈ A e for e ∈ E, a set Q ⊂ E is called a feasible query set if there exists a spanning tree T in G such that T has minimum weight with respect to any weight function w : E → R which fulfills that w(e) = w e if e ∈ Q and w(e) ∈ A e if e ∈ E − Q.We say that Q verifies T .
MST-U thus consists in finding a feasible query set Q of minimum query cost e∈Q q e .Moreover, we will use the following definition: Given an uncertainty graph G = (G, (A e ) e ) and a cycle C in G, we say that an edge f is always maximal in C if L f ≥ U e for all e in C − f .

Vertex uncertainty problem
In an instance of the Minimum Spanning Tree Problem under Explorable Vertex Uncertainty (V-MST-U) we are given an undirected, connected graph G where each vertex corresponds to a point in the Euclidean plane.The weight of an edge is determined by the distance between its end vertices.Instead of the precise location of a vertex v we are given an uncertainty set A v ⊂ R 2 .A v can either be a singleton set (in which case we refer to the vertex and the uncertainty set as trivial) or an open subset of R 2 .An algorithm can query a vertex v at query cost q v to reveal its exact location.We define a (vertex-)uncertainty graph as well as a feasible (vertex) query set in the same way as in the setting of MST-U.Then V-MST-U is defined analogously to MST-U, i.e. we want to identify a feasible vertex query set of minimum query cost.In order to apply methods developed for MST-U to V-MST-U it is common to transform vertex uncertainty sets into edge uncertainty sets by computing all possible distances between vertices.The resulting instance is referred to as associated edge instance: Definition Given an instance I of V-MST-U with graph G = (V, E) and uncertainty sets A v , v ∈ V , the associated edge instance I ′ is an instance of MST-U with graph G and uncertainty sets

Performance analysis
To analyze the quality of a solution found by an algorithm we compute the competitive ratio between the query cost of the algorithm's solution and the cost of an optimal query set.An optimal query set is an optimal solution to the offline problem where all edge weights (or vertex positions) are known a priori.
Definition Let I be an instance of MST-U (or V-MST-U).By OP T (I ) we denote the cost of an optimal query set for instance I .For an algorithm ALG we denote by ALG(I ) the cost of the query set which the algorithm outputs when applied to I .We say that ALG achieves competitive ratio c for all instances I .A randomized algorithm is said to achieve competitive ratio c ≥ 1 if the ratio between the expected query cost of the algorithm's solution and the cost of an optimal solution is at most c, i.e. if for all instances I .

Structural aspects of MST-U and V-MST-U
In the following we will recall some structural insights into MST-U which were provided by Megow et al in [11] and will be used throughout the remainder of the paper.Given an instance of MST-U, a lower limit tree is the edge set of a minimum spanning tree in G where all edge weights are set equal to the lower limit of the edge's uncertainty set.An upper limit tree is defined analogously.
Lemma 1 ([11]) Let T L , T U be a lower and an upper limit tree respectively.All edges in T L \T U with non-trivial uncertainty sets lie in any feasible query set.
Hence, the instance can be preprocessed by querying all edges in T L \T U and we may thus assume that T L = T U .Lemma 1 can be translated to the setting of vertex uncertainty in the following: Lemma 2 Given a V-MST-U instance I , let T L , T U be a lower and an upper limit tree of the associated edge instance I ′ .Then every feasible query set for I contains a vertex cover of {e ∈ T L \T U |e contains a non-trivial vertex} which consists of non-trivial vertices only.

Now recall the following well-known properties of minimum spanning trees:
Given a cycle C in a weighted graph G, we have that if an edge e is such that w e > w e ′ for all e ′ ∈ C − e then e is not contained in any MST.If w e ≥ w e ′ for all e ′ ∈ C then there exists an MST of G which does not contain e.In the context of MST-U this means that if we encounter a cyle C with an always maximal edge e then e can be discarded in the search for an MST.Conversely, given a cycle C and a non-trivial edge f which has largest upper limit U f in C, it is impossible to verify an MST which contains f without querying f because f is a candidate for an edge with strictly largest weight in C. Possible candidates for a largest weight edge in C are f and all edges e in C with possibly larger weight than f , i.e. with U e > L f .We will refer to these edges as neighbors of f and denote the set of all neighbors by X(f prove the following with respect to f and its neighbor set: ) Let T U be an upper limit tree.Let f be an edge in G − T U and let C be the cycle in T U + f .If no edge in C is always maximal then any feasible query set contains f or X(f ).Moreover, if there is an edge g = f in C such that L g ≥ L f and U g = L f then f lies in any feasible query set.
If T U = T L is a lower limit tree too and no edge is known to have maximum weight even after querying f or all edges in X(f ) then an edge g in C with maximum upper limit U g lies in any feasible query set.
In the context of V-MST-U, we can derive the following result from Lemma 3: Lemma 4 Consider an instance I of V-MST-U and let T U be an upper limit tree for the associated edge instance I ′ .Let f be an edge in G − T U and let C be the cycle in T U + f .If no edge in C is always maximal in I ′ then any feasible query set for I contains a non-trivial vertex in f or a vertex cover of {e ∈ X(f )|e contains a non-trivial vertex} which consists of non-trivial vertices only.Moreover, if there is an edge g = f in C such that L g ≥ L f and U g = L f then any feasible query set of I contains a non-trivial vertex in f .
We omit a formal proof of Lemma 2 and of Lemma 4 as they follow directly from Lemma 1 and Lemma 3 and the fact that an MST for a vertex-uncertainty graph can only be identified if the edge-uncertainty graph of the associated edge instance allows to identify an MST.

A randomized algorithm for MST-U on cactus graphs
In this section we consider a randomized algorithm for MST-U on cactus graphs.A cactus graph is a connected graph in which any two cycles share at most one vertex.A feasible query set needs to allow for the detection of a maximum weight edge in each cycle.It can be easily seen that an optimal query set for a cactus graph consists of the disjoint union of the optimal query sets for each of the graph's cycles.Thus we can first consider MST-U on a cycle and then extend the result to the case of an edge uncertainty graph which is a cactus.
Once we are able to treat cycles separately, it is possible to achieve an optimal competitive ratio of 1.5 using the following observation: Assume that we have preprocessed the instance such that T L = T U and let f be an edge in G − T L and let C be the cycle in T L + f .Assume moreover that no edge in C is always maximal.Then Lemma 3 guarantees that if we start by querying f and continue to query edges in order of decreasing upper limit until an edge in C is always maximal, then we have queried at most one edge which is not in the optimal solution.
Theorem 5 For cactus graphs there exists an algorithm Random C with competitive ratio at most 1.5, which is optimal.Moreover, if G is a cycle, Random C achieves competitive ratio 1+ where q X(f ) denotes the cumulative query cost of edges in X(f ).
Proof We first consider a graph C which consists of a single cycle.Assume again that we have preprocessed the instance such that T L = T U and that no always maximal edge in C is known.Let f be the edge in E \ T L and let q X(f ) := e∈X(fi) q e be the query cost of all neighbors of f in C. With probability p, our algorithm starts by querying all edges in X(f ).With probability 1 − p, its first step is to query f .Once it has queried X(f ) or f , it queries edges in order of decreasing upper limit until an always maximal edge in C can be identified.
We distinguish two cases: either an optimal solution queries f or it does not.If an optimal solution does not query f , it must by Lemma 3 query all of the neighbors in X(f ) and thus makes queries at cost q X(f ) .In this case with probability p, we query the same edges as the optimal solution and achieve competitive ratio 1.With probability 1 − p, Random C queries f and possibly all edges in the neighbor set X(f ) such that the competitive ratio is at most q X(f ) +q f q X(f ) .Thus, in this case the overall competitive ratio is at most 1 + (1 − p) If an optimal solution queries f , Random C queries the same edges as the optimal solution if it starts by querying f , i.e. with probability 1 − p.With probability p, Random C starts by querying all neighbors in X(f ) and might have to query f too, while an optimal query set might contain f only.Summing up, the competitive ratio is bounded by 1 + p • q X(f ) q f in this case.By setting , the obtained bounds for both cases coincide and equal .
Note that the following equivalences hold: Thus, Random C is 1.5-competitive on instances where the uncertainty graph is a cycle if p is chosen as above.
For an instance I where the uncertainty graph is a general cactus G, we again preprocess the instance such that T L = T U is a lower and an upper limit tree.Denote the edges in G − T L by f 1 , ..., f m−n+1 , the order is arbitrary.Let C i denote the cycle in T L + f i .We apply Random C for cycles as described above to each of the cycles seperately.Let Q * i denote an optimal query set for an instance where the uncertainty graph consists only of C i and the uncertainty sets and weights are as in I .We set As any two cycles in G do not share common edges and edges that lie in no cycle need to be part of any spanning tree, the disjoint union i is an optimal solution for I and thus OP T (I ) = m−n+1 i=1 OP T i .Moreover, the structure of cactus graphs guarantees that for any i = 1, ..., m − n + 1, X(f i ) is independent of the choice of queries that Random C makes when applied to C j with j = i as well as the queries' outcome.Let q prep denote the cost of queries made in the preprocessing.We denote by ALG i the cost of the queries Random C makes when applied to C i , i ∈ {1, 2, ..., m − n + 1}.As we expect at most 1.5 • OP T i queries when applying Random C to C i , we obtain that This completes the proof of the competitiveness.Note that the correctness of Random C is immediate as for each cycle the algorithm proceeds to query edges until an edge becomes always maximal.The optimality follows from the fact that no randomized algorithm can achieve a competitive ratio less than 1.5 even on triangles, see [4].A precise description of Random C for general query costs is given in Algorithm 1.

V-MST-U and randomization
We will now turn to the vertex uncertainty version of MST-U which has not been considered in the context of randomized algorithms so far.We start by showing that no randomized algorithm for V-MST-U can achieve a better competitive ratio than 2.5.Our proof is based on the proof of the bound for the deterministic performance guarantee by [5].

Theorem 6
No randomized algorithm for V-MST-U can achieve a competitive ratio less than 2.5.This remains true even for cycles and under the assumption of uniform query costs.
Proof We will prove the theorem by applying a variant of Yao's Principle (see [1]) which allows to derive a lower bound for the performance of randomized input : An instance of MST-U with cactus graph G = (V, E), uncertainty sets A e and query costs q e , e ∈ E output: A feasible query set Q 1 Draw b uniformly at random from [0, 1]; 2 Preprocess the instance such that add all edges in X(f i ) to Q and query them.The algorithm Random C for MST-U with general query costs in cactus graphs algorithms from the best possible expected performance of a deterministic algorithm against a finite randomized family of instances.A finite randomized family of instances is a pair (R, p) where R is a finite set of instances for V-MST-U and p is a probability vector of length |R| which indicates for each instance R ∈ R the probability of its occurance.In [3], Erlebach and Hoffmann define a graph G with four non-trivial vertices A, B, C and D. For each such vertex v ∈ {A, B, C, D} they provide an instance R v where vertex positions are such that {v} is the only optimal query set while after having queried any combination S ⊂ {A, B, C, D} \ {v} of the other vertices, vertex positions can still turn out to be as in R u with u ∈ {A, B, C, D} \ S. For more details, see Figure 1.
Consider now the randomized family of instances (R, p), where Then no deterministic algorithm ALG achieves a better expected competitive ratio E R∼pR ALG(R) OP T (R) than the algorithm ALG 1 which queries A, B, C, D (or less if an MST can already be identified) in this order independently from the queries' results.This is due to the fact that querying v only reveals whether or not we are facing instance R v but if not, it is indistinguishable which of the remaining instances it might be.Then by Yao's Principle, no randomized where A denotes the class of all deterministic algorithms.

A randomized algorithm for V-MST-U on cactus-like graphs
V-MST-U structurally differs from MST-U mainly due to the following two aspects: a) Querying a single end vertex of an edge already yields partial information about the edge's length.
b) A vertex may be incident to several edges.Thus, knowing its precise position impacts on the possible lengths of all adjacent edges.
While for MST-U it is sometimes possible to identify edges which have to lie in any feasible query set, it becomes significantly harder to tell whether a vertex has to be queried due to aspect a).However, we will make use of the weaker statement that for certain edges at least one out of two end vertices needs to be queried.
Similarly to the special case of cactus graphs for MST-U, we will now consider instances of V-MST-U where no two cycles share a non-trivial vertex and query costs are uniform.This makes it easier to deal with aspect b), as vertex queries may only impact on the possible lengths of at most two adjacent edges.We will refer to vertex-uncertainty graphs where cycles do not intersect in non-trivial vertices as cactus-like.Our algorithm considers cycles separately.For an instance I with a cycle C, our algorithm works as follows: First, it computes the associated edge instance and preprocesses the instance s.t.T L = T U holds.
Then it identifies an edge f with largest upper limit U f in C. Usually, our algorithm deterministically queries the end vertices of f and will then query the end vertices of edges in C in order of decreasing upper limit in the associated edge instance until a longest edge in C can be identified.Only if the neighbor set is small (where "small" is yet to be defined) we will make use of randomization.In case that the neighbor set is large and the algorithm performs deterministically, we will say that the algorithm follows the deterministic procedure.
Remark: To simplify notation, we will w.l.o.g.assume throughout this section that all uncertainty sets in associated edge instances have the form of intervals.However, the argumentation can be translated straightforwardly to the general case, e.g. by replacing A f contains A e by L f ≤ L e ≤ U e ≤ U f where one out of two consecutive inequalities is strict.

Preprocessing
If T L = T U there is exactly one edge in T L \ T U because C is a cycle.Our preprocessing consists in repeatedly computing T L and T U for the associated edge instance and querying the end vertices of the edge in T L \T U until T L = T U .However, the property T L = T U does not necessarily remain true throughout the algorithm as vertex queries have impact on the uncertainty sets of all adjacent edges.

Deterministic procedure
We will now argue why the deterministic procedure makes at most 2•OP T (I )+2 queries.
Lemma 7 Let I be an instance of V-MST-U on a cycle C.Let ALG be an algorithm which computes the associated edge instance and in each subsequent step queries the end vertices of an edge with largest upper limit in the associated edge instance until a longest edge is found.Then ALG makes at most 2•OP T (I )+2 queries when applied to I .Moreover, if I is such that T L = T U , f 1 ∈ C − T L is the first edge with largest upper limit considered by ALG and Q * is an optimal query set with f 1 ∩ Q * = ∅ then ALG makes at most 2.5 • OP T (I ) queries when applied to I .
Proof We will denote by {u i , v i } the set of vertices that ALG queries during the i'th step.(Note that u i = v i is possible if the edge considered in the i'th step has one trivial end vertex.)Moreover, we will denote by V i the set of vertices queried during the first i steps such that |V T | = ALG(I ) where T is the last iteration.Let Q * be an optimal query set and denote by A i e , U i e and L i e the uncertainty set, upper limit and lower limit of an edge e in iteration i.We will argue that for each iteration i it either holds that at least one vertex in {u i , v i } lies in Q * or that for each j < i at least one vertex in {u j , v j } lies in Q * .This trivially holds for the first iteration.Assume now that it is known to be true for iterations 1, ..., i − 1 and consider the i-th iteration.Note that u i and v i are non-trivial end vertices of an edge f which has largest upper limit U i f in the uncertainty graph considered in iteration i.First assume that there exists an edge e ∈ C with A i e ⊂ A i f .Then by Lemma 4 we need to know the position of at least one of f 's end vertices in order to be able to identify a minimum spanning tree.Now assume that none of the other uncertainty sets is a subset of A i f .By induction hypothesis we know that there is at most one j > i for which we have not yet argued that {u j , v j } intersects with Q * .Let h be the edge with largest upper limit in iteration j such that u j and v j are end vertices of h.Then w h can neither lie in f as f has largest upper limit in the i-th iteration.Hence we know that w h < w f and thus h lies in any MST.Let g be a longest edge in C. By the choice of h we have that U j h ≥ U j g ≥ w g and thus without querying neither u j nor v j (which are the non-trivial end vertices of h in iteration j) we will not be able to verify an MST which does not contain g.From this the first part of the lemma follows: Let j be the last step for which we cannot guarantee that v j or u j lies in any feasible query set.Then we know that half of V j−1 lies in Q * and that for each step i > j we know that v i or u i lies in . Note that if j = 1 then u j = v j : By the choice of j, no uncertainty set is contained in A j e where e is the edge with largest upper limit in iteration j and non-trivial end vertices u j and v j .Thus w f1 ≤ L e which cannot be the case if both end vertices of e remain unqueried until iteration j due to our preprocessing.Hence, the first iteration is the only iteration where we might query two vertices none of which is in Q * and thus if Q * ∩ f 1 = ∅ then ALG makes at most 2 • OP T (I ) + 1 queries, i.e. it achieves competitive ratio 2.5.unless OP T (I ) = 1.However, if OP T (I ) = 1 and Q * intersects f 1 then Q * is a subset of f 1 and thus the deterministic procedure finishes after querying only the end vertices of f 1 .This proves the second part of the claim.

Randomization
The above lemma guarantees that the deterministic procedure achieves a competitive ratio of 2 + 2 OP T (I ) which is at most 2.5 unless OP T (I ) ≤ 3. We will first handle the exception where OP T (I ) = 3 by making a slight adaption: The algorithm starts with the first three iterations of the deterministic procedure.
In the fourth iteration it queries a vertex in {u 4 , v 4 } with probability 0.5 (or probability 1 if u 4 = v 4 ), then queries the other vertex if necessary and finally proceeds with the deterministic procedure if still no longest edge can be identified.See Algorithm 2 for a precise description of the algorithm Rand3 that is applied to the uncertainty graph that results from querying f 1 's end vertices.
Lemma 8 Let I be a preprocessed instance of V-MST-U on a cycle C.Let ALG be an algorithm which computes the associated edge instance, queries the end vertices of an edge f 1 with largest upper limit in the associated edge instance and applies Rand3 to the resulting uncertainty graph.Then ALG achieves competitive ratio 2.5 when applied to I unless OP T (I ) ≤ 2 and f 1 ∩ Q * = ∅ for all optimal query sets Q * .
Proof Again we denote by {u i , v i } the set of vertices that ALG queries during the i'th step (i.e.{u 1 , v 1 } = f 1 ).The algorithm ALG makes at most as many queries as the deterministic procedure.Thus if Q * ∩ f 1 = ∅ or OP T (I ) ≥ 4 then the claim follows from Lemma 7. Assume now that Q * ∩ f 1 = ∅ and OP T (I ) = 3.If the algorithm finishes after the first three iterations then it has made at most 6 queries and yields a competitive ratio of at most 2. If the algorithm has not finished after the first three iterations, then we know from the proof of Lemma 7 that two of the three sets {u 1 , v 1 } {u 2 , v 2 } and {u 3 , v 3 } intersect with Q * such that {u 4 , v 4 } contains the last vertex in Q * .Hence, we expect to make 0.5 • (7 + 8) queries which yields a competitive ratio of at most 2.5.
input : An instance I of V-MST-U with uniform query costs with a cycle C = (V, E) and uncertainty sets A v for v ∈ V output: A feasible query set Q Following from Lemma 8, we only need to deal with instances where OP T (I ) ≤ 2 and f 1 ∩ Q * = ∅.Thus we first check whether the (original) uncertainty graph contains candidates for a feasible query set W of size at most 2 that does not contain an end vertex of f 1 .We do so by computing the size a of a smallest vertex cover of the non-trivial edges in X(f 1 ) which does not intersect f 1 and consists of non-trivial vertices only.Note that if there is a feasible query set of size at most 2 which does not intersect the edge f 1 then a ≤ 2 by Lemma 4.
If a = 1 we apply a randomized procedure Rand1 as described below.If a = 2, we query the end vertices of f 1 and depending on the outcome either decide to stick to the strategy Rand3 or apply a randomized strategy as described below.
input : An instance I of V-MST-U with uniform query costs with a cycle C = (V, E) and uncertainty sets A v , v ∈ V output: A feasible query set Q 1 Compute the associated edge instance; 2 Initialize Q = ∅; 3 Let f 1 be an edge with largest upper limit and let X(f 1 ) be the set of Case a = 1 : If a = 1 then X(f 1 ) either consists of a single edge e or of two edges g and h which are incident to each other but not to f 1 (see Figure 2).The algorithm picks an order in which to query the three (or four) vertices in (g ∩ h) ∪ f 1 or e ∪ f 1 uniformly at random and queries the vertices in the respective order up to the point where a longest edge in C can be identified.If necessary, it queries the remaining vertices in X(f 1 ).See Algorithm 3 for a precise description.
Case a = 2 : The algorithm starts by querying the end vertices of f 1 .Let g be an edge in the resulting uncertainty graph with largest upper limit U g .If now w f1 ≤ L g then we continue as in Rand3.If w f1 ∈ A g then the algorithm picks a vertex cover W of X(f 1 ) which contains |W | = 2 non-trivial vertices such that W ∩ f 1 = ∅ uniformly at random.The algorithm queries the vertices in W but starts with a vertex in W ∩ g.After that it queries the end vertices of edges in order of decreasing upper limit.For a precise description, see Algorithm 4.
input : An instance I of V-MST-U with uniform query costs with a cycle C = (V, E) and uncertainty sets A v , v ∈ V output: A feasible query set Q 1 Compute the associated edge instance and T L ; 2 Initialize Q = ∅; 3 Let f 1 be the edge in R := E \ T L and let X(f 1 ) be the set of edges g ∈ T L ∩ C with U g > L f1 ; 4 Query f 1 and add its end vertices to Q; 5 Let g be an edge with largest upper limit in C;  with OP T (I ) = |Q * | < 4 where Q * is an optimal query set.If OP T (I ) = 1 then a = 2 implies that Q * ⊂ f 1 by Lemma 4 and the vertex in Q * is queried within the first two queries.Say OP T (I ) = 2. Let g be an edge with largest upper limit in the associated edge instance after having queried the end vertices of f 1 .We will distinguis the cases where Q * either intersects f 1 or not.First assume that Q * ∩ f 1 = ∅.If Q * = f 1 then the claim trivially holds.We thus assume that |Q * ∩ f 1 | = 1.If w f1 ≤ L g we proceed as in Rand3 and the claim follows from Lemma 8. Thus, consider the case where w f1 ∈ A g .Rand2 proceeds by querying a vertex cover of X(f 1 ).We will now argue that if still no longest edge is found and h is an edge which subsequently has largest upper limit in C then the remaining vertex v ∈ Q * is the (unique) non-trivial end vertex of h.If Q * verifies an MST which contains h then Q * contains the end vertex of h otherwise h will remain a candidate for a strictly longest edge.Note that h is not incident to f 1 otherwise h would be trivial after querying f 1 and a vertex cover of X(f 1 ).Thus after querying f 1 we have that w f1 ∈ A h due to the preprocessing which proves that v needs to be an end vertex of h if Q * verifies that h is a longest edge in C. Hence, if OP T (I ) = 2 and Q * ∩ f 1 = ∅ we can verify an MST after querying the end vertices of f 1 , a vertex cover of size 2 and an end vertex of h which proves a competitive ratio of at most 2.5.Assume now that Q * ∩ f 1 = ∅.By Lemma 4, this implies that Q * is a vertex cover of X(f 1 ) (which verifies that f 1 is a longest edge in C).Say Rand2 picks a vertex cover which is not a feasible query set.During any of the following steps, let g be an edge which currently has largest weight in C. Then A g contains w f1 and thus Q * contains the non-trivial vertex of g else g cannot be shown to have at most the weight of f 1 .Note that we can have at most four different smallest vertex covers of X(f 1 ) of which do not intersect f 1 and at most two which are pairwise disjoint from each other (see Figure 3).Thus with probabilty at most 1  4 we pick Q * right away, with probability 1 4 we pick a vertex cover that is disjoint from Q * and need two additional queries while with probability 1  2 , we pick a vertex cover that intersects with Q * in a single vertex after which we need to make one more query.This leads to a competitive ratio Theorem 10 For instances of V-MST-U with uniform query cost where no two cycles intersect in a non-trivial vertex the algorithm V-Random C achieves a competitive ratio of 2.5 and this is best possible.
Proof Let I be an instance with uncertainty graph G to which we apply V-Random C .For a cycle C in G we denote by Q * C an optimal query set for an instance of V-MST-U with graph C and uncertainty sets and weights as in I .If we prove for each such cycle C that V-Random C achieves a competitive ratio of 2.5 when applied to C the claim follows because Q * = ˙ C Q * C is an optimal query set for I .Moreover, Lemma 2 guarantees that each vertex pair queried during the preprocessing intersects with Q * .Thus we assume that I is a preprocessed instance of V-MST-U with uncertainty graph C where C is a cylce.Let Q * be an optimal query set for I .Now we prove that V-Random C queries at most 2.5 • OP T (I ) vertices when applied to I .First assume that a ≥ 3, i.e. the algorithm queries the end vertices of f 1 and applies Rand3 to the resulting uncertainty graph.From a ≥ 3 it follows by Lemma 4 that Q * ∩ f 1 = ∅ or OP T (I ) ≥ a ≥ 4 and thus the claim follows from Lemma 8. if we assume that a = 2 then the claim follows from Lemma 9. Finally, assume that a = 1.Note that the maximum number of vertices in f 1 ∪ V (X(f 1 )) is 5. Thus we make at most five queries and only need to consider the case where OP T (I ) = 1.The neighbor set X(f 1 ) consists either of a single edge e or of two intersecting edges g and h.In the first case, each non-trivial vertex in e ∪ f 1 could be a feasible query set of size one and we find the vertex in Q * within at most 1  4 (1 + 2 + 3 + 4) = 2.5 queries in expectation.In the second case each non-trivial vertex in (g ∩ h) ∪ f 1 could be a feasible query set of size one and we find the vertex in Q * within 1  3 (1 + 2 + 3) = 2 queries in expectation.Note that if a = 0 then f i has no neighbors and is thus always maximal right away.The optimality follows from Theorem 6 and the fact that all uncertainty graphs used throughout its proof are cycles.

Minimum Spanning Stars
Several online algorithms exist for MST-U and are shown to deliver a solution the cost of which is bounded by a constant multiple of the cost of an optimal solution.But what happens if we ask to find a minimum spanning tree of a specified type at minimum query cost?For many types of special spanning trees, it is already NP-hard to find such a tree in a graph, e.g.Hamiltonian paths or spiders (see Gargano et al. [8]).In the following we will thus consider spanning stars which are generally easy to find.Definition The complete bipartite graph K 1,k is called a star and is denoted by S k .We will refer to the vertex with degree k as centre of S k .If a graph G with n vertices contains S n−1 as a subgraph, then S n−1 is said to be a spanning star in G.
We define the Minimum Spanning Star Problem under Explorable Uncertainty (MSS-U) analogously to MST-U, i.e. we want to identify a minimum spanning star by making queries of as little weight as possible.However, it turns out that no algorithm for MSS-U can achieve constant competitive ratio.
Theorem 11 There exists no algorithm for MSS-U which achieves constant competitive ratio.
Proof We prove the theorem by defining for each n ∈ N a finite family (I k n ) k of instances with uniform query cost on a graph G with n vertices such that every algorithm needs to make at least (n − 2) times as many queries as necessary on at least one instance in (I k n ) k .For n = 5 the construction is illustrated in Figure 4. Consider a graph G = (V, E) with V = {v 1 , ..., v n } and E = {{v 1 , v i }|i = 2, ..., n} ∪ {{v n , v i }|i = 1, ..., n − 1}.Then G has precisely two spanning stars, one with centre v 1 and the other one with centre v n .(All other vertices have degree 2.) Let q e = 1 for all e ∈ E. We define the uncertainty sets as follows: • A {v1,vn} = {1}, • A {v1,vi} = (0, 1) for i = 2, ..., n − 1 and • A {n,vi} = (0, n) for i = 2, ..., n − 1.
For j ∈ {2, ..., n − 1}, I j n is defined such that w {vj ,vn} = n − 1 and w e = 0.5 for all e ∈ E \ {{v j , v n }, {v 1 , v n }}.It is then sufficient to query only the edge {v j , v n } to know that the spanning star with center v n has larger weight.Conversely, without querying {v j , v n }, it is impossible to tell which spanning star has minimum weight.Note that for an algorithm all non-trivial edges adjacent to v n are undistinguishable.It has thus to decide on an order in which these edges are queried.If j is such that {v j , v n } is the last edge adjacent to v n to be queried by an algorithm then the algorithm competitive ratio at least n − 2 when applied to instance I j n .

Conclusion
In this paper we considered the Minimum Spanning Tree Problem Under Explorable Uncertainty (MST-U) and the related Minimum Spanning Tree Problem Under Explorable Vertex Uncertainty (V-MST-U) for specified instance types where cycles can be considered independently from each other.We provided a randomized algorithm for MST-U on cactus graphs and proved that it achieves a competitive ratio of 1.5 which is best possible.For V-MST-U instances where cycles do not share non-trivial vertices and query costs are uniform, we provided the algorithm V-Random C which achieves a competitive ratio of 2.5.We showed that 2.5 is a lower bound for the performance of randomized algorithms for V-MST-U which remains true even for instances with uniform query cost where the uncertainty graph is a cycle.Thus, the performance guarantee shown for V-Random C is best possible.Finally, we introduced the Minimum Spanning Star Problem under Explorable Uncertainty (MSS-U) and proved that no algorithm for MSS-U can achieve constant competitive ratio.(V-)MST-U in itself is a problem which still deserves further investigation.A major open question in the setting of MST-U is whether there exists a randomized algorithm with a competitive ratio of 1.5 for general instances as well or whether the lower bound of 1.5 can be improved for instances where the graph is not necessarily a cactus.As for V-MST-U, no randomized algorithm for general V-MST-U instances exists so far and even for the special case where cycles intersect in trivial vertices only, the performance guarantee of V-Random C relies on the fact that query costs are uniform.Note that no deterministic algorithm with constant competitive ratio for V-MST-U with non-uniform query costs is known either.Moreover, different models of uncertainty exploration could be subject of further research.Consider for instance a scenario where installing a camera in a certain location allows to measure the distance between itself and all surrounding objects.A setting like this could motivate a hybrid model between edge and vertex uncertainty where edge weights are uncertain but known to lie inside given uncertainty sets and can be revealed upon querying an adjacent vertex.
Add f i to Q and query f i .14 while no edge in the cycle C i is always maximal do 15 Query an unqueried edge e ∈ C i \ Q with maximum U e and add it to Q. Algorithm 1:

Figure 1 :
Figure 1: Instances R A , R B , R C and R D for the finite randomized family (R, p) of instances

1 9 Algorithm 2 :
Compute the associated edge instance and T L ; 2 Initialize Q = ∅; 3 for i ← 1 to 2 do 4 if no edge in C is always maximal then 5 Let g be an edge with largest upper limit in C; 6 Query the end vertices of g and add them to Q 7 if no edge in C is always maximal then 8 Let g be an edge with largest upper limit in C and let u, v be the non-trivial end vertices of g; Pick b ∈ [0, 1] uniformly at random; 10 if b ≤ 0.5 then 11 Query u and add it to Q; 12 if no edge in C is always maximal then 13 Query v and add it to Q 14 else 15 Query v and add it to Q; 16 if no edge in C is always maximal then 17 Query u and add it to Q 18 while no edge in C is always maximal do 19 Let g be an edge with largest upper limit in C; 20 Query the end vertices of g and add them to Q The subroutine Rand3 of V-Random C

8 j := 1; 9 while 11 j 1 ) 3 :
no edge in C is always maximal and j < k do 10 Query v σi(j) and add it to Q ; := j + 1; 12 if no edge in C is always maximal then 13 Query the remaining vertices in X(f Algorithm The subroutine Rand1 of V-Random C

Algorithm 4 : 1 Figure 2 :Lemma 9 1 Figure 3 :
Figure 2: Sketches of cycles with a = 1 where edges in X(f 1 ) are bold and dashed lines indicate parts of the cycle that are not in X(f 1 ) ∪ f 1 .In (a) and (b) Rand1 picks a vertex in {w 1 , w 2 , w 3 } with probability 1 3 each.In (c) Rand1 picks a vertex in {w 1 , w 2 , w 3 , w 4 } with probability 1 4 each.

4 Figure 4 :
Figure4: The weight of {v 2 , v 5 } is 4. All missing edge weights equal 0.5.An optimal solution only needs to query {v 2 , v 5 } which has larger weight than the star with center v 1 can have.A deterministic algorithm can not distinguish between the edges {v 2 , v 5 }, {v 3 , v 5 } and {v 4 , v 5 } and might have to query all three of them.
which consists of non-trivial vertices only} and index the elements W 1 , ..., W |W | arbitrarily;