Showing papers on "Greedy algorithm published in 1988"
TL;DR: In this article, a weighted greedy algorithm is proposed for a version of the dynamic Steiner tree problem, which allows endpoints to come and go during the life of a connection.
Abstract: The author addresses the problem of routing connections in a large-scale packet-switched network supporting multipoint communications. He gives a formal definition of several versions of the multipoint problem, including both static and dynamic versions. He looks at the Steiner tree problem as an example of the static problem and considers the experimental performance of two approximation algorithms for this problem. A weighted greedy algorithm is considered for a version of the dynamic problem which allows endpoints to come and go during the life of a connection. One of the static algorithms serves as a reference to measure the performance of the proposed weighted greedy algorithm in a series of experiments. >
2,866 citations
TL;DR: The author proposes a family of heuristic algorithms for Stone's classic model of communicating tasks whose goal is the minimization of the total execution and communication costs incurred by an assignment, and augments this model to include interference costs which reflect the degree of incompatibility between two tasks.
Abstract: Investigate the problem of static task assignment in distributed computing systems, i.e. given a set of k communicating tasks to be executed on a distributed system of n processors, to which processor should each task be assigned? The author proposes a family of heuristic algorithms for Stone's classic model of communicating tasks whose goal is the minimization of the total execution and communication costs incurred by an assignment. In addition, she augments this model to include interference costs which reflect the degree of incompatibility between two tasks. Whereas high communication costs serve as a force of attraction between tasks, causing them to be assigned to the same processor, interference costs serve as a force of repulsion between tasks, causing them to be distributed over many processors. The inclusion of interference costs in the model yields assignments with greater concurrency, thus overcoming the tendency of Stone's model to assign all tasks to one or a few processors. Simulation results show that the algorithms perform well and in particular, that the highly efficient Simple Greedy Algorithm performs almost as well as more complex heuristic algorithms. >
424 citations
TL;DR: This paper presents a model of an s, S inventory system in which there are two priority classes of customers and an approximate, renewal-based model is derived which develops a greedy heuristic which minimizes expected costs subject to a fill-rate service constraint.
Abstract: This paper presents a model of an s, S inventory system in which there are two priority classes of customers. The model treats excess demands as lost sales and can accommodate an arbitrary deterministic lead time. After considering the associated Markov-chain model, an approximate, renewal-based model is derived. This approximation is used to develop a greedy heuristic which minimizes expected costs subject to a fill-rate service constraint. The paper concludes with the results of an extensive numerical test of both the accuracy of the approximation and the performance of the heuristic with respect to the true optimal solution. Results indicate good performance which deteriorates as the fill rate requirement and lead time increase.
174 citations
TL;DR: A neural model version of the Kohonen algorithm is given, closer to classical neural networks, for traveling salesman problem using only this algorithm, without energy function nor any parameter choosen “ad hoc”, to find good suboptimal tours.
Abstract: We present an application of the Kohonen algorithm to the traveling salesman problem: Using only this algorithm, without energy function nor any parameter choosen "ad hoc", we found good suboptimal tours. We give a neural model version of this algorithm, closer to classical neural networks. This is illustrated with various numerical examples.
125 citations
TL;DR: It is shown that the throughput of the closed queueing network has a monotonicity property, such that any optimal allocation must give more servers to stations with a higher workload.
Abstract: We study the problem of allocating a given number of identical servers among the work centers of a manufacturing system. The problem is formulated as a nonlinear integer program of allocating servers in a closed queueing network to maximize throughput. We show that the throughput of the closed queueing network has a monotonicity property, such that any optimal allocation must give more servers to stations with a higher workload. The number of allocations that satisfy this property is much smaller than the total number of feasible allocations. This property and a bounding technique for the throughput of the closed queueing network are combined to develop a search algorithm to obtain an optimal allocation of servers. A greedy heuristic is also developed, and its optimality proven in the special case of a two-center system in the general case, its optimality remains a conjecture.
94 citations
TL;DR: A heuristic for the traveling salesman location problem on a network that requires On3 time to find the location that "minimizes" the expected distance traveled is presented.
Abstract: In this paper, we present a heuristic for the traveling salesman location problem on a network. Each day the salesman e.g., a repair vehicle must visit all the calls that are registered in a service list. Each call is generated with a given probability and the service list contains at most n calls. The heuristic requires On3 time to find the location that "minimizes" the expected distance traveled. A worst case analysis of the heuristic indicates that it will produce a solution which is at most 50% worse than the optimal solution. The paper also contains several asymptotic results for the problem in the plane.
92 citations
TL;DR: The greedy algorithm solves the problem of batching jobs which must be processed on a single machine and in the case of various job types a heuristic is given which has given outstanding results on randomly generated examples.
76 citations
16 Mar 1988
TL;DR: A heuristic greedy multicast algorithm which guarantees a minimized message delivery time is proposed and results show that the greedy algorithm is very close to an optimal solution.
Abstract: Existing hypercube multiprocessors only support one-to-one interprocessor communication. However, multicast (one-to-many) communication is needed for executing many data-parallel algorithms. An optimal multicast algorithm should be able to minimize both the traffic generated and the time required to delivery a message. By modeling this problem as a graph-theoretical problem, the authors conjecture that the finding of an optimal solution is NP-hard. A heuristic greedy multicast algorithm which guarantees a minimized message delivery time is proposed. Routing of multicast messages is done in a distributed manner. Simulation results show that the greedy algorithm is very close to an optimal solution. >
31 citations
11 Apr 1988
TL;DR: A method for segmenting images into a discrete set of classes by first segmenting at low resolution and then progressing to finer resolutions until individual pixels are classified, which results in accurate segmentations and requires significantly less computation than some previously known methods.
Abstract: A method is presented for segmenting images into a discrete set of classes by first segmenting at low resolution and then progressing to finer resolutions until individual pixels are classified. This multiple resolution method results in accurate segmentations and requires significantly less computation than some previously known methods. The segmentation algorithm used at each resolution is based on maximum a posteriori estimation of the field of pixel classifications, which is modeled as a Markov random field. The maximization is performed by a deterministic greedy algorithm which iteratively chooses the classification of individual pixels or blocks of pixels. A texture model is also developed which allows the extraction of a texture statistic for each pixel and is well suited for use with the proposed algorithm. Measurements of algorithm performance under varying conditions of region size and signal-to-noise ratio are presented. >
29 citations
TL;DR: This work studies the behavior of G n, the sum of the lengths of the segments produced by the greedy heuristic, which provides an approximate solution to the Euclidean matching problem by successively matching the two closest unmatched points.
Abstract: Given a collection of n points in the plane, the Euclidean matching problem is the task of decomposing the collection into matched pairs connected by line segments in such a way as to minimize the sum of all the segment lengths. The greedy heuristic provides an approximate solution to the Euclidean matching problem by successively matching the two closest unmatched points. We study the behavior of Gn, the sum of the lengths of the segments produced by the greedy heuristic.
22 citations
01 Feb 1988
TL;DR: The authors address the data allocation problem in a dynamically reconfigurable distributed database system by proposing several dynamic allocation strategies that choose the optimal assignment using heuristic benefit functions and greedy search strategy.
Abstract: The authors address the data allocation problem in a dynamically reconfigurable distributed database system. Following the description of the system model and the consequences of node movement, several dynamic allocation strategies are presented. A distributed candidate-selection algorithm using the data from the accounting system in the database servers is proposed to reduce the number of files and nodes considered in reallocation. The allocation algorithms choose the optimal assignment using heuristic benefit functions and greedy search strategy. The experimental results demonstrate the accuracy and efficiency of the allocation algorithms. >
01 Jan 1988
TL;DR: It is conjecture that the optimal multicast tree problem remains NP-hard even for hypercube topology, and a heuristic greedy multicast algorithm which guarantees a minimized message delivery time is proposed.
Abstract: An efficient interprocessor communication mechanism is essential to the performance of hypercube multiprocessors. All existing hypercube multiprocessors basically support one-to-one interprocessor communication only. However, multi-destination communication (multicast), which is highly demanded in executing many data parallel algorithms, is not directly supported by existing hypercube multiprocessors. A multicast algorithm should attempt to inform each destination in a minimum number of time steps while generating a least amount of traffic. This problem is formally modeled as a graph theoretical problem, the Optimal Multicast Tree problem. We conjecture that the optimal multicast tree problem remains NP-hard even for hypercube topology. A heuristic greedy multicast algorithm which guarantees a minimized message delivery time is proposed. Simulation results show that the performance of the greedy algorithm is very close to optimal solution. Routing of multicast messages is done in a distributed manner.
TL;DR: The strategy in this paper is to reduce the problem to several problems such that no matter what instance is started with, at least one of these problems can be solved optimally by a greedy method.
Abstract: The problem of connecting a set of terminals that lie on the sides of a rectangle to minimize the total area is discussed. An O(n) algorithm is presented to solve this problem when the set of n terminals is initially sorted. The strategy in this paper is to reduce the problem to several problems such that no matter what instance is started with, at least one of these problems can be solved optimally by a greedy method.
06 Dec 1988
TL;DR: It is shown that the problem of finding an optimal schedule is NP-hard and a greedy algorithm is given to find a optimal schedule for a large class of task systems.
Abstract: The problem of preemptively scheduling a task system consisting of a set of n independent tasks on one processor so as to minimize the mean flow time is considered. The goal is to find a preemptive schedule such that the mean flow time is minimized subject to the constraint that task T/sub i/ is executed within the interval between its release time and its deadline. Such a schedule, if it exists, is called an optimal schedule. It is shown that the problem of finding an optimal schedule is NP-hard. A greedy algorithm is given to find an optimal schedule for a large class of task systems. >
01 Jan 1988
TL;DR: An implicit enumeration algorithm which can be used to find one or all maximum cliques in a graph using depth-first search and a branching rule based on the number of triangles to which vertices belong is described.
Abstract: We describe an implicit enumeration algorithm which can be used to find one or all maximum cliques in a graph. The procedure builds cliques one vertex at a time using depth-first search and a branching rule based on the number of triangles to which vertices belong. Computational results for moderately-sized graphs are reported and the algorithm is shown to be competitive for relatively sparse graphs.
01 Jan 1988
TL;DR: This paper presents a greedy mapping algorithm for hypercube interconnection structures, which utilizes the graph-oriented mapping strategy to map a communication graph to a hypercube.
Abstract: The mapping problem is the problem of implementing a computational task on a target architecture in order to maximize some performance metric. For a hypercube-interconnected multiprocessor, the mapping problem arises when the topology of a task graph is different from a hypercube. It is desirable to find a mapping of tasks to processors that minimizes average path length and hence interprocessor communication. The problem of finding an optimal mapping, however, has been proven to be NP-complete. Several different approaches have been taken to discover suitable mappings for a variety of target architectures. Since the mapping problem is NP-complete, approximation algorithms are used to find good mappings instead of optimal ones. Usually, greedy and/or local search algorithms are introduced to approximate the optimal solutions. This paper presents a greedy mapping algorithm for hypercube interconnection structures, which utilizes the graph-oriented mapping strategy to map a communication graph to a hypercube. The strategy is compared to previous strategies for attacking the mapping problem. A simulation is performed to estimate both the worst-case bounds for the greedy mapping strategy and the average performance.
TL;DR: A methodology is given for modeling a problem and solving it using the A* algorithm, mechanically generated from the simplified problem, which is derived by relaxing each of the predicate formulas describing the rules and the goal state of the problem.
Abstract: A methodology is given for modeling a problem and solving it using the A* algorithm. The heuristic used for A* is mechanically generated from the simplified problem, which is derived by relaxing each of the predicate formulas describing the rules and the goal state of the problem. The generated heuristic satisfies the conditions of admissibility and monotonicity. The methodology is applicable for solving general problems. The overall procedure for this methodology is illustrated by four well-known problems, namely, the eight-puzzle problem, the traveling salesman problem, the robot planning problem, and the consistent labeling problem. The values of the heuristics generated by this procedure are compared to the corresponding values of problem-oriented heuristics reported in the literature. >
05 Dec 1988
TL;DR: The modeling results support the notion that simple greedy heuristic algorithms such as are proposed by many researchers are sufficient in that they are likely to lead to near-optimal strategies and that increasing the overhead in forming strategies is only marginally beneficial.
Abstract: This paper examines heuristic algorithms for processing distributed queries using generalized joins. As this optimization problem is NP-hard heuristic algorithms are deemed to be justified. A heuristic algorithm to form/formulate strategies to process queries is presented. It has a special property in that its overhead can be “controlled”: The higher its overhead the better the strategies it produces. Modeling on a test-bed of queries is used to demonstrate that there is a trade-off between the strategy's execution and formulation delays. The modeling results also support the notion that simple greedy heuristic algorithms such as are proposed by many researchers are sufficient in that they are likely to lead to near-optimal strategies and that increasing the overhead in forming strategies is only marginally beneficial. Both the strategy formulation and execution delays are examined in relation to the number of operations specified by the strategy and the total size of partial results.
TL;DR: This work generalizes the problem of maximizing a linear objective function over the polyhedron by considering a submodular function on a co-intersecting family and gives an algorithm for solving it.
Abstract: A greedy algorithm solves the problem of maximizing a linear objective function over the polyhedron (called the submodular polyhedron) determined by a submodular function on a distributive lattice or a ring family. We generalize the problem by considering a submodular function on a co-intersecting family and give an algorithm for solving it. Here, simple-minded greedy augmentations do not work any more and some complicated augmentations with multiple exchanges are required. We can find an optimal solution by at most 1/2n(n − 1) augmentations, wheren is the number of the variables and we assume a certain oracle for computing multiple exchange capacities.
16 Mar 1988
TL;DR: It is shown that, in situations in which a good partition is crucial, simulated annealing is the most effective algorithm.
Abstract: Results are presented on the effectiveness of several algorithms for partitioning graphs with weighted nodes and edges. Such graphs can represent a number of interesting program structures, such as processes using message passing or dataflow graphs and other distributed software. The graph partitions can be used in software tools to control the allocation of program units to distributed processes in ways which minimize communication cost, completion time or utilization. It is shown that, in situations in which a good partition is crucial, simulated annealing is the most effective algorithm. It is, however, an expensive algorithm to run, and when this is important good results can still be obtained by using a variant of a greedy algorithm. A number of other algorithms that can be useful in particular situations are described. Those can be of practical use to distributed system designers. >
TL;DR: Hereditary set systems for which a modified greedy algorithm is optimal are characterized, which will involve an algorithmic characterization of strong map relations between matroids.
TL;DR: The expected value of the total cost of the matching found by the heuristic is shown to be less than six if the costs are independent and identically distributed uniformly in the unit interval.
Abstract: We present a heuristic to solve the $m \times m$ assignment problem in $O(m^2 )$ time. The assignment problem is formulated as a weighted complete bipartite graph $G = (S,T,E)$, $|S| = |T| = m$. For convenience we assume that m is even. The main procedure in the heuristic is to construct a graph $G_d = (S,T,E_d )$ which is a subgraph of G, $|E_d | = 4dn$, $n = {m / 2}$, such that we can find a perfect matching in $G_d $ with probability at least $1 - \frac{1}{3}({d / n})^{d^2 - 4d - 1} $. An $O(|S||E|)$ exact algorithm is used to find a minimum weight matching M in $G_d $. Any unmatched vertices in G relative to M are then matched by a greedy algorithm. The expected value of the total cost of the matching found by the heuristic is shown to be less than six if the costs are independent and identically distributed uniformly in the unit interval. Further, with the above probability, the heuristic produces a solution which is at most six times the optimal solution.
TL;DR: An algorithm for solving the jump number problem on arbitrary posets is presented which extends the author’s approach applied to N-free posets and makes use of two new types of greedy chains in posets introduced in companion papers.
01 Jan 1988
TL;DR: Simulating the logic of natural evolution has been proposed as a method for generating artificial intelligence through the automation of inductive inference and Evolutionary Programming is used for route optimization using a traveling salesman problem.
Abstract: Simulating the logic of natural evolution has been proposed as a method for generating artificial intelligence through the automation of inductive inference. Here, Evolutionary Programming is used for route optimization using a traveling salesman problem. This approach is compared to using the greedy algorithm on a fifty city problem. The percentage of tours that are superior to the evolved solution is estimated.
25 Oct 1988
TL;DR: This paper presents a multiple resolution algorithm for maximizing the a posteriori probability associated with a class of MRF's, which combine the smooth regions found in Gaussian random fields with the abrupt boundaries characteristic of discrete valued MRf's.
Abstract: Regularization of optical flow estimates and the restoration of noisy images are examples of problems which may be solved by modeling the unknown field as a Markov random field (MRF) and calculating the maximum a posteriori (MAP) estimate. This paper presents a multiple resolution algorithm for maximizing the a posteriori probability associated with a class of MRF's. These MRF's combine the smooth regions found in Gaussian random fields with the abrupt boundaries characteristic of discrete valued MRF's. This makes them well suited for modeling image properties which vary smoothly over large regions but change abruptly at object boundaries. The multiple resolution algorithm first performs the maximization at coarse resolution and then proceeds to finer resolutions until the pixel level is reached. Since coarser resolution solutions are used to guide maximization at finer resolutions, the algorithm is resistant to local maxima and has performance equivalent to simulated annealing, but with dramatically reduced computation. In fact, the multiple resolution algorithm has been found to require less computation than local greedy algorithms because constraints propagate more rapidly at coarse resolutions. Regularization of optical flow problems and the restoration of fields corrupted with additive white Gaussian noise are explicitly treated and simulation results are presented.
TL;DR: Both theoretical and empirical evidence are presented to suggest that this method finds solutions that are near optimal, and it is shown that the relative error goes to zero as the problem size goes to infinity.
Abstract: A greedy heuristic that schedules jobs on one machine is examined. The problem considered is to minimize the sum of weighted completion times subject to deadline constraints. Both theoretical and empirical evidence are presented to suggest that this method finds solutions that are near optimal. Optimality conditions are developed. Also, an analysis of the relative error is presented. Worst case bounds are found that are based on the problem parameters. In addition, we show that the relative error goes to zero as the problem size goes to infinity.
01 Jan 1988
TL;DR: An algorithm for constructing the greedy triangulation of any planar straight-line graph with n vertices in time O(n2 log n) and space O( n) is presented and a theorem suggesting a good expected time-performance of the presented algorithm is proven.
Abstract: An algorithm for constructing the greedy triangulation of any planar straight-line graph with n vertices in time O(n2 log n) and space O(n) is presented. The upper time-space bound implied by the algorithm in particular improves Gilbert's simultaneous O(n2 log n)-time and O(n2)-space bound for finding the greedy triangulation of an n-point planar point set. A theorem suggesting a good expected time-performance of the presented algorithm is proven.
TL;DR: This work reports computational experience with the greedy procedure, demonstrates its superiority to a well known network simplex code, Gnet, implemented on the classical network formulation of the problem, and shows that the problem has a rather interesting network structure.
28 Jun 1988
TL;DR: This paper studies a scheduling problem, called the Delay Problem, that models an aspect of the loop parallelization problem, and shows that the Delay problem is NP-Complete when the precedence constraints are a set of arbitrary trees.
Abstract: Automatic parallelization of code written in a sequential language such as FORTRAN is of great importance. One natural approach to loop parallelization is to assign separate invocations of a loop to different processors. However, it is often necessary to delay the starting times of loops to avoid violating data dependences. In this paper we study a scheduling problem, called the Delay Problem, that models an aspect of the loop parallelization problem. We show that the Delay Problem is NP-Complete when the precedence constraints are a set of arbitrary trees. Our major result of the paper is a polynomial time algorithm for the case where the precedence constraints are a forest of in-trees or a forest of out-trees. This covers an important practical case for the Delay Problem.
IBM1
TL;DR: This note describes some sufficient conditions for the maximum or minimum of a weighted flow, of given volume in a series parallel graph to be found by a greedy algorithm.
Abstract: This note describes some sufficient conditions for the maximum or minimum of a weighted flow (the weights are on paths, and are derived from weights on the edges of the path), of given volume in a series parallel graph to be found by a greedy algorithm.