We present an all-pairs shortest path algorithm for arbitrary graphs that performs O(mn log (m; n)) comparison and addition operations, where m and n are the number of edges and vertices, resp., and is Tarjan's inverse-Ackermann function. Our algorithm eliminates the sorting bottleneck inherent in approaches based on Dijkstra's algorithm, and for graphs with O(n) edges our algorithm is within a tiny O(log (n; n)) factor of optimal. Our algorithm can be implemented to run in polynomial time (granted, a large polynomial). We leave open the problem of providing an efficient implementation.

There are several fundamental problems whose deterministic complexity remains unresolved, but for which there exist randomized algorithms whose complexity is equal to known lower bounds. Among such problems are the minimum spanning tree problem, the set maxima problem, the problem of computing connected components and (minimum) spanning trees in parallel, and the problem of performing sensitivity analysis on shortest path trees and minimum spanning trees. However, while each of these problems has a randomized algorithm whose performance meets a known lower bound, all of these randomized algorithms use a number of random bits which is linear in the number of operations they perform. We address the issue of reducing the number of random bits used in these randomized algorithms. For each of the problems listed above, we present randomized algorithms that have optimal performance but use only a polylogarithmic number of random bits; for some of the problems our optimal algorithms use only log n random bits. Our results represent an exponential savings in the amount of randomness used to achieve the same optimal performance as in the earlier algorithms. Our techniques are general and could likely be applied to other problems.

We investigate the single link failure recovery problem and its application to the alternate path routing problem for ATM networks. Specifically, given a 2-connected graph G, a specified node s, and a shortest paths tree T s = fe 1 ; e 2 ; : : : ; e n\Gamma1 g of s, where e i = (x i ; y i ) and x i = parent Ts (y i ), find a shortest path from y i to s in the graph Gne i for 1 i n \Gamma 1. We present an O(m + n log n) time algorithm for this problem and a linear time algorithm for the case when all weights are equal. When the edge weights are integers, we present an algorithm that takes O(m+ T sort (n)) time where T sort (n) is the time required to sort n integers. We show that any solution to the single link recovery problem can adapted to solve the alternate path routing problem in ATM networks.

This article presents two simple deterministic algorithms for nding the Minimum Spanning Tree in O(jV j + jEj) time for any proper class of graphs closed on graph minors, which includes planar graphs and graphs of bounded genus. Both algorithms require no a priori knowledge of the structure of the class except for its density; edge weights are only compared and no random access to data is needed.

1 Introduction The minimum spanning tree (MST) problem has seen a flurry of activity lately, driven largely by the success of a new approach to the problem. The recent MST algorithms [20, 8, 29, 28], despite their superficial differences, are all based on the idea of progressively improving an approximately minimum solution, until the actual minimum spanning tree is found. It is still likely that this progressive improvement approach will bear fruit. However, the current

Model checking is a promising technology, which has been applied for verification of many hardware and software systems. In this paper, we introduce the concept of model update towards the development of an automatic system modification tool that extends model checking functions. We define primitive update operations on the models of Computation Tree Logic (CTL) and formalize the principle of minimal change for CTL model update. These primitive update operations, together with the underlying minimal change principle, serve as the foundation for CTL model update. Essential semantic and computational characterizations are provided for our CTL model update approach. We then describe a formal algorithm that implements this approach. We also illustrate two case studies of CTL model updates for the well-known microwave oven example and the Andrew File System 1, from which we further propose a method to optimize the update results in complex system modifications. 1.

In this paper we present several Bayesian algorithms for learning Tree Augmented Naive Bayes (TAN) models. First we correct Meila and Jaakkola (Meila and Jaakkola, 2000a) results for Bayesian learning with tree belief networks. Then we show that these results can be extended to TANs by proving that accepting a prior decomposable distribution over TAN's, we can compute the exact Bayesian model averaging over TAN structures and parameters in polynomial time. Furthermore, we prove that the k-maximum a posteriori (MAP) TAN structures can also be computed in polynomial time. We use these results to construct several TAN based classifiers. We show that these classifiers provide consistently better predictions over Irvine datasets and artificially generated data than TAN based classifiers proposed in the literature.

We present near optimal algorithms for two problems related to finding the replacement paths for edges with respect to shortest paths in sparse graphs. The problems essentially study how the shortest paths change as edges on the path fail, one at a time.

For many fundamental problems there exist randomized algorithms that are asymptotically optimal and are superior to the best known deterministic algorithm. Among these are the minimum spanning tree (MST) problem, the MST sensitivity analysis problem, the parallel connected components and parallel minimum spanning tree problems, and the local sorting and set maxima problems. (For the first two problems there are provably optimal deterministic algorithms with unknown, and possibly superlinear running times.) One downside of the randomized methods for solving these problems is that they use a number of random bits linear in the size of the input. In this paper we develop some general methods for reducing exponentially the consumption of random bits in comparison based algorithms. In some cases we are able to reduce the number of random bits from linear to nearly constant without affecting the expected running time. Most of our results are obtained by adjusting or reorganizing existing randomized algorithms to work well with a pairwise or O(1)-wise independent sampler. The prominent exception — and the main focus of this paper — is a linear-time randomized minimum spanning tree algorithm that is not derived from the well known Karger-Klein-Tarjan algorithm. In many ways it resembles more closely the deterministic minimum spanning tree algorithms based on Soft Heaps. Further,

This paper is devoted to an online variant of the minimum spanning tree problem in randomly weighted graphs. We assume that the input graph is complete and the edge weights are uniform distributed over [0, 1]. An algorithm receives the edges one by one and has to decide immediately whether to include the current edge into the spanning tree or to reject it. The corresponding edge sequence is determined by some adversary. We propose an algorithm which achieves E [ALG] /E [OPT] = O (1) and E [ALG/OPT] = O (1) against a fair adaptive adversary, i.e., an adversary which determines the edge order online and is fair in a sense that he does not know more about the edge weights than the algorithm. Furthermore, we prove that no online algorithm performs better than E [ALG] /E [OPT] =# (log n) if the adversary knows the edge weights in advance. This lower bound is tight, since there is an algorithm which yields E [ALG] /E [OPT] = O (log n) against the strongest imaginable adversary. 1.