Nimrod Megiddo

Linear-Time Algorithms for Linear Programming in

Linear-time for Linear Programming in R2 and R3 are presented. The methods used are applicable for some other problems. For example, a linear-time algorithm is given for the classical problem of finding the smallest circle enclosing n given points in the plane. This disproves a conjecture by Shamos and Hoey that this problem requires Ω(n log n) time. An immediate consequence of the main result is that the problem of linear separability is solvable in linear-time. This corrects an error in Shamos and Hoeys paper, namely, that their O(n log n) algorithm for this problem in the plane was optimal. Also, a linear-time algorithm is given for the problem of finding the weighted center of a tree and algorithms for other common location-theoretic problems are indicated. The results apply also to the problem of convex quadratic programming in three-dimensions. The results have already been extended to higher dimensions and we know that linear programming can be solved in linear-time when the dimension is fixed. This will be reported elsewhere; a preliminary report is available from the author.

R^3

The goal of this paper is to point out that analyses of parallelism in computational problems have practical implications even when multi-processor machines are not available. This is true because, in many cases, a good parallel algorithm for one problem may turn out to be useful for designing an efficient serial algorithm for another problem. A unified framework for cases like this is presented. Particular cases, which are discussed in this paper, provide motivation for examining parallelism in problems like sorting, selection, minimum-spanning-tree, shortest route, maxflow, matrix multiplication, as well as scheduling and locational problems.

and Related Problems

It is demonstrated that the linear programming problem in d variables and n constraints can be solved in O(n) time when d is fixed. This bound follows from a multidimensional search technique which is applicable for quadratic programming as well. There is also developed an algorithm that is polynomial in both n and d provided d is bounded by a certain slowly growing function of n.

Applying Parallel Computation Algorithms in the Design of Serial Algorithms

This chapter presents continuous paths leading to the set of optimal solutions of a linear programming problem. These paths are derived from the weighted logarithmic barrier function. The defining equations are bilinear and have some nice primal-dual symmetry properties. Extensions to the general linear complementarity problem are indicated.

Linear Programming in Linear Time When the Dimension Is Fixed

Given n demand points in the plane, the p-center problem is to find p supply points (anywhere in the plane) so as to minimize the maximum distance from a demand point to its respective nearest supply point. The p-median problem is to minimize the sum of distances from demand points to their respective nearest supply points. We prove that the p-center and the p-median problems relative to both the Euclidean and the rectilinear metrics are NP-hard. In fact, we prove that it is NP-hard even to approximate the p-center problems sufficiently closely. The reductions are from 3-satisfiability.

Pathways to the optimal set in linear programming

Now welcome, the most inspiring book today from a very professional writer in the world, a unified approach to interior point algorithms for linear complementarity problems lecture notes in computer science vol 538. This is the book that many people in the world waiting for to publish. After the announced of this book, the book lovers are really curious to see how this book is actually. Are you one of them? Thats very proper. You may not be regret now to seek for this book to read.

On the complexity of some common geometric location problems

A method for locating data anomalies in a k dimensional data cube that includes the steps of associating a surprise value with each cell of a data cube, and indicating a data anomaly when the surprise value associated with a cell exceeds a predetermined exception threshold. According to one aspect of the invention, the surprise value associated with each cell is a composite value that is based on at least one of a Self-Exp value for the cell, an In-Exp value for the cell and a Path-Exp value for the cell. Preferably, the step of associating the surprise value with each cell includes the steps of determining a Self-Exp value for the cell, determining an In-Exp value for the cell, determining a Path-Exp value for the cell, and then generating the surprise value for the cell based on the Self-Exp value, the In-Exp value and the Path-value.

A Unified Approach to Interior Point Algorithms for Linear Complementarity Problems

Let A be the problem of minimizing c1, x1, +... + cnxn subject to certain constraints on x = x1,..., xn, and let B be the problem of minimizing a0 + a1x1 +... + anxn/b0 + b1x1 +... + bnxn subject to the same constraints, assuming the denominator is always positive. It is shown that if A is solvable within O[pn] comparisons and O[qn] additions, then B is solvable in time O[pnqn + pn]. This applies to most of the “network” algorithms. Consequently, minimum ratio cycles, minimum ratio spanning trees, minimum ratio simple paths, maximum ratio weighted matchings, etc., can be computed withing polynomial-time in the number of variables. This improves a result of E. L. Lawler, namely, that a minimum ratio cycle can be computed within a time bound which is polynomial in the number of bits required to specify an instance of the problem. A recent result on minimum ratio spanning trees by R. Chandrasekaran is also improved by the general arguments presented in this paper. Algorithms of time-complexity O|E| · |V|2 · log|V| for a minimum ratio cycle and O|E| · log2|V| · log log |V| for a minimum ratio spanning tree are developed.

Discovery-Driven Exploration of OLAP Data Cubes

T. Parsons proposed and partially analyzed the following pursuit-evasion problem on graphs: A team of searchers traverse the edges of a graph G in pursuit of a fugitive, who moves along the edges of the graph with complete knowledge of the locations of the pursuers. What is the smallest number s(G) of searchers that will suffice for guaranteeing capture of the fugitive? We show that determining whether s(G) ≤ K, for a given integer K, is NP-hard for general graphs but can be solved in linear time for trees. We also provide a structural characterization of those graphs with s(G) ≤ K for K = 1,2,3.

Combinatorial Optimization with Rational Objective Functions

A range query applies an aggregation operation over all selected cells of an OLAP data cube where the selection is specified by providing ranges of values for numeric dimensions. We present fast algorithms for range queries for two types of aggregation operations: SUM and MAX. These two operations cover techniques required for most popular aggregation operations, such as those supported by SQL. For range-sum queries, the essential idea is to precompute some auxiliary information (prefix sums) that is used to answer ad hoc queries at run-time. By maintaining auxiliary information which is of the same size as the data cube, all range queries for a given cube can be answered in constant time, irrespective of the size of the sub-cube circumscribed by a query. Alternatively, one can keep auxiliary information which is 1/bd of the size of the d-dimensional data cube. Response to a range query may now require access to some cells of the data cube in addition to the access to the auxiliary information, but the overall time complexity is typically reduced significantly. We also discuss how the precomputed information is incrementally updated by batching updates to the data cube. Finally, we present algorithms for choosing the subset of the data cube dimensions for which the auxiliary information is computed and the blocking factor to use for each such subset. Our approach to answering range-max queries is based on precomputed max over balanced hierarchical tree structures. We use a branch-and-bound-like procedure to speed up the finding of max in a region. We also show that with a branch-and-bound procedure, the average-case complexity is much smaller than the worst-case complexity.