Efficient Linear-time Algorithm Research Articles

Classifying seismograms using the FastMap algorithm and support-vector machines

Neural networks and related deep learning methods are currently at the leading edge of technologies used for classifying complex objects such as seismograms. However they generally demand large amounts of time and data for model training and their learned models can sometimes be difficult to interpret. FastMapSVM is an interpretable machine learning framework for classifying complex objects, combining the complementary strengths of FastMap with support vector machines (SVMs) and extending the applicability of SVMs to domains with complex objects. FastMap is an efficient linear-time algorithm that maps complex objects to points in a Euclidean space while preserving pairwise domain-specific distances between them. Here we invoke FastMapSVM as a lightweight alternative to neural networks for classifying seismograms. We demonstrate that FastMapSVM outperforms other state-of-the-art methods for classifying seismograms when train data or time is limited. We also show that FastMapSVM can provide an insightful visualization of seismogram clustering behaviour and thus earthquake classification boundaries. We expect FastMapSVM to be viable for classification tasks in many other real-world domains.

Asymptotic Optimality of a Time Optimal Path Parametrization Algorithm

Time Optimal Path Parametrization is the problem of minimizing the time interval during which an actuation constrained agent can traverse a given path. Recently, an efficient linear-time algorithm for solving this problem was proposed. However, its optimality was proved for only a strict subclass of problems solved optimally by more computationally intensive approaches based on convex programming. In this paper, we prove that the same linear-time algorithm is asymptotically optimal for all problems solved optimally by convex optimization approaches. We also characterize the optimum of the Time Optimal Path Parametrization Problem, which may be of independent interest.

Dynamic Economic Lot-Sizing Problem: A new O(T) Algorithm for the Wagner-Whitin Model

Abstract Wagner and Whitin (1958) develop an algorithm to solve the dynamic Economic Lot-Sizing Problem (ELSP), which is widely applied in inventory control, production planning, and capacity planning. The original algorithm runs in O ( T 2 ) time, where T is the number of periods of the problem instance. Subsequently, other researchers develop linear-time algorithms to solve the Wagner-Whitin (WW) lot-sizing problem; examples include the ELSP and equivalent Single Machine Batch-Sizing Problem (SMBSP). This paper revisits the algorithms for the ELSP and SMBSP under WW cost structure, presents a new efficient linear-time algorithm, and compares the developed algorithm with equivalent algorithms in the literature. The developed algorithm employs a lists and stacks data structure, which is a completely different approach than that of the comparable algorithms for the ELSP and SMBSP. Analysis of the developed algorithm shows that it executes fewer different actions throughout and hence it improves execution time by a maximum of 51.40% for the ELSP and 29.03% for the SMBSP.

Space Efficient Linear Time Algorithms for BFS, DFS and Applications

Research on space efficient graph algorithms, particularly for st-connectivity, has a long history including the celebrated polynomial time, O(lg n) bits1 algorithm in undirected graphs by Reingold J. JACM. 55(4) (2008), and polynomial time, \(n/2^{\Theta (\sqrt {\lg n})}\) bits algorithm in directed graphs by Barnes et al. SICOMP. 27(5), 1273–1282 (1998). Recent works by Asano et al. ISAAC (2014) and Elmasry et al. STACS (2015), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. Elmasry et al. gave, among others, an implementation of breadth first search (BFS) in a graph G with n vertices and m edges, taking the optimal O(m + n) time using O(n) bits improving the naive O(n lg n) bits implementation. Similarly, Asano et al. provided space efficient implementations for performing depth first search (DFS) in a graph G. We continue this line of work focusing on improving the space requirement for implementing a few classical graph algorithms. Our first result is a simple data structure that can maintain any subset S of a universe of u elements using just u + o(u) bits and supports in constant time, apart from the standard insert, delete and membership queries, the operation findany that finds and returns any element of the set (or outputs that the set is empty). It can also enumerate all elements present currently in the set in no particular order in O(k + 1) time where k is the number of elements currently belonging to the set. While this data structure supports a weaker set of operations than that of Elmasry et al. STACS (2015), it is simple, more space efficient and is sufficient to support a BFS implementation optimally in O(m + n) time using at most 2n + o(n) bits. Later, we further improve the space requirement of BFS to at most n lg 3 + o(n) bits albeit with a slight increase in running time to O(m lg nf(n)) time where f(n) is any extremely slow growing function of n, and the o term in the space is a function of f(n). We also discuss a similar time-space tradeoff result for finding a minimum weight spanning tree of a weighted (bounded by polynomial in n) undirected graph using n + O(n/f(n)) bits and O(m lg nf(n)) time, for any function f(n) such that 1 ≤ f(n) ≤ n. For DFS in a graph G, we provide an implementation taking O(m + n) time and O(n lg m/n) bits. This partially answers at least for sparse graphs, a question asked by Asano et al. ISAAC (2014) whether DFS can be performed in O (m + n) time and using O(n) bits, and also simultaneously improves the DFS result of Elmasry et al. STACS (2015). Using our DFS algorithm and other careful implementations, we show how one can also test for biconnectivity, 2-edge connectivity, and find cut vertices and bridges of a given undirected graph within the same time and space bounds; earlier classical linear time algorithms for these problems used Ω(n lg n) bits of space.

A linear-time algorithm for finding a paired 2-disjoint path cover in the cube of a connected graph

For a connected graph G=(V(G),E(G)) and two disjoint subsets of V(G) A={α1,…,αk} and B={β1,…,βk}, a paired (many-to-many) k-disjoint path cover of G joining A and B is a vertex-disjoint path cover {P1,…,Pk} such that Pi is a path from αi to βi for 1≤i≤k. In the recent paper, Park and Ihm (2014) presented a necessary and sufficient condition for a paired 2-disjoint path cover joining two vertex sets to exist in the cube of a connected graph. In this paper, we propose an O(|V(G)|+|E(G)|)-time algorithm that actually finds such a paired 2-disjoint path cover. In particular, we show that, in order to build a desired disjoint path cover, it is sufficient to consider only the edges of a carefully selected spanning tree of the graph and at most one additional edge not in the tree, which allows an efficient linear-time algorithm.

Complexity of Inferences in Polytree-shaped Semi-Qualitative Probabilistic Networks

Semi-qualitative probabilistic networks (SQPNs) merge two important graphical model formalisms: Bayesian networks and qualitative probabilistic networks. They provide a very general modeling framework by allowing the combination of numeric and qualitative assessments over a discrete domain, and can be compactly encoded by exploiting the same factorization of joint probability distributions that are behind the Bayesian networks. This paper explores the computational complexity of semi-qualitative probabilistic networks, and takes the polytree-shaped networks as its main target. We show that the inference problem is coNP-Complete for binary polytrees with multiple observed nodes. We also show that inferences can be performed in time linear in the number of nodes if there is a single observed node. Because our proof is constructive, we obtain an efficient linear time algorithm for SQPNs under such assumptions. To the best of our knowledge, this is the first exact polynomial-time algorithm for SQPNs. Together these results provide a clear picture of the inferential complexity in polytree-shaped SQPNs.

Efficient Full-Chip Statistical Leakage Analysis Based on Fast Matrix Vector Product

Power consumption has become a major concern since the integrated circuit industry entered the nanometer design regime. Due to the increasing process variation, deterministic leakage power analysis becomes inadequate and thus statistical analysis is required. The challenges of statistical leakage analysis are that the huge number of random variables make trivial computation of the variance in O(N2) time impractical for realistic designs and that knowing only the first two moments is not sufficient to obtain the distribution of the full-chip leakage. In this paper, we introduce efficient linear time algorithms for statistical leakage analysis. To enable those algorithms, a fast matrix vector product technique is crucial, being applied not only to compute the second moment of the total leakage, but also, combined with a comonotonic approximation, to estimate the distribution function of the total leakage power. The computational complexity of the proposed algorithms is provably O(N), and the experimental result is presented with detailed discussion, indicating promising improvement in terms of accuracy.

Evaluating entity resolution results

Entity Resolution (ER) is the process of identifying groups of records that refer to the same real-world entity. Various measures (e.g., pairwise F 1 , cluster F 1 ) have been used for evaluating ER results. However, ER measures tend to be chosen in an ad-hoc fashion without careful thought as to what defines a good result for the specific application at hand. In this paper, our contributions are twofold. First, we conduct an analysis on existing ER measures, showing that they can often conflict with each other by ranking the results of ER algorithms differently. Second, we explore a new distance measure for ER (called "generalized merge distance" or GMD ) inspired by the edit distance of strings, using cluster splits and merges as its basic operations. A significant advantage of GMD is that the cost functions for splits and merges can be configured, enabling us to clearly understand the characteristics of a defined GMD measure. Surprisingly, a state-of-the-art clustering measure called Variation of Information is a special case of our configurable GMD measure, and the widely used pairwise F 1 measure can be directly computed using GMD . We present an efficient linear-time algorithm that correctly computes the GMD measure for a large class of cost functions that satisfy reasonable properties.

Developing New Locality Results for the Prüfer Code using a Remarkable Linear-Time Decoding Algorithm

The Prüfer Code is a bijection between the $n^{n-2}$ trees on the vertex set $[1,n]$ and the $n^{n-2}$ strings in the set $[1,n]^{n-2}$ (known as Prüfer strings of order $n$). Efficient linear-time algorithms for decoding (i.e., converting string to tree) and encoding (i.e., converting tree to string) are well-known. In this paper, we examine an improved decoding algorithm (due to Cho et al.) that scans the elements of the Prüfer string in reverse order, rather than in the usual forward direction. We show that the algorithm runs in linear time without requiring additional data strutures or sorting routines, and is an 'online' algorithm — every time a new string element is read, the algorithm can correctly output an additional tree edge without any knowledge of the future composition of the string. This new decoding algorithm allows us to derive results concerning the 'locality' properties of the Prüfer Code (i.e., the effect of making small changes to a Prüfer string on the structure of the corresponding tree). First, we show that mutating the $\mu$th element of a Prüfer string (of any order) causes at most $\mu + 1$ edge-changes in the corresponding tree. We also show that randomly mutating the first element of a random Prüfer string of order $n$ causes two edge-changes in the corresponding tree with probability $2(n-3)/n(n-1)$, and one edge-change otherwise. Then, based on computer-aided enumerations, we make three conjectures concerning the locality properties of the Prüfer Code, including a formula for the probability that a random mutation to the $\mu$th element of a random Prüfer string of order $n$ causes exactly one edge-change in the corresponding tree. We show that if this formula is correct, then the probability that a random mutation to a random Prüfer string of order $n$ causes exactly one edge-change in the corresponding tree is asymptotically equal to one-third, as $n$ tends to infinity.

Nonlinear programming approaches to decoding low-density parity-check codes

We consider the decoding problem for low-density parity-check codes, and apply nonlinear programming methods. This extends previous work using linear programming (LP) to decode linear block codes. First, a multistage LP decoder based on the branch-and-bound method is proposed. This decoder makes use of the maximum-likelihood-certificate property of the LP decoder to refine the results when an error is reported. Second, we transform the original LP decoding formulation into a box-constrained quadratic programming form. Efficient linear-time parallel and serial decoding algorithms are proposed and their convergence properties are investigated. Extensive simulation studies are performed to assess the performance of the proposed decoders. It is seen that the proposed multistage LP decoder outperforms the conventional sum-product (SP) decoder considerably for low-density parity-check (LDPC) codes with short to medium block length. The proposed box-constrained quadratic programming decoder has less complexity than the SP decoder and yields much better performance for LDPC codes with regular structure

Linear-time modular decomposition of directed graphs

Modular decomposition of graphs is a powerful tool with many applications in graph theory and optimization. There are efficient linear-time algorithms that compute the decomposition for undirected ...

Linear-time modular decomposition of directed graphs

Modular decomposition of graphs is a powerful tool with many applications in graph theory and optimization. There are efficient linear-time algorithms that compute the decomposition for undirected graphs. The best previously published time bound for directed graphs is O ( n + m log n ) , where n is the number of vertices and m is the number of edges. We give an O ( n + m ) -time algorithm.

Drawing Planar Graphs with Large Vertices and Thick Edges

We consider the problem of representing size information in the edges and vertices of a planar graph. Such information can be used, for example, to depict a network of computers and information traveling through the network. We present an efficient linear-time algorithm which draws edges and vertices of varying 2-dimensional areas to represent the amount of information flowing through them. The algorithm avoids all occlusions of nodes and edges, while still drawing the graph on a compact integer grid.

An efficient algorithm for constructing Hamiltonian paths in meshes

This paper presents an efficient linear-time sequential algorithm for constructing Hamiltonian paths between two given vertices in meshes with horizontal size m and vertical size n. The algorithm first partitions the given mesh into a number of submeshes in constant steps, and then constructs a Hamiltonian cycle or path in each submesh and combines them together to become a complete Hamiltonian path in mn steps. Our algorithm has improved the previous algorithm [6] by reducing the number of partition steps from O( m+ n) to only a constant. Moreover, we show that our algorithm can be optimally parallelized to obtain a constant-time parallel algorithm on the weakest parallel machine without need of inter-processor communication, while this cannot be achieved for the previous algorithm.

On sparse evaluation representations

The sparse evaluation graph has emerged over the past several years as an intermediate representation that captures the dataflow information in a program compactly and helps perform dataflow analysis efficiently. The contributions of this paper are three-fold: • We present a linear time algorithm for constructing a variant of the sparse evaluation graph for any dataflow analysis problem. Our algorithm has two advantages over previous algorithms for constructing sparse evaluation graphs. First, it is simpler to understand and implement. Second, our algorithm generates a more compact representation than the one generated by previous algorithms. (Our algorithm is also as efficient as the most efficient known algorithm for the problem.) • We present a formal definition of an equivalent flow graph, which attempts to capture the goals of sparse evaluation. We present a quadratic algorithm for constructing an equivalent flow graph consisting of the minimum number of vertices possible. We show that the problem of constructing an equivalent flow graph consisting of the minimum number of vertices and edges is NP-hard. • We generalize the notion of an equivalent flow graph to that of a partially equivalent flow graph, an even more compact representation, utilizing the fact that the dataflow solution is not required at every node of the control-flow graph. We also present an efficient linear time algorithm for constructing a partially equivalent flow graph.

An efficient and provably correct algorithm for the multiscale estimation of image contours by means of polygonal lines

A large portion of image contours is characterized by local properties such as sharp variations of the image intensity across the contour. The integration of local image descriptors estimated by using these local properties into curvilinear descriptors is a difficult problem from a theoretical viewpoint because of the combinatorially large number of possible curvilinear descriptors. To deal with this difficulty, the notion of compressible graphs is introduced and a contour data model is defined leading to an efficient linear-time algorithm which provably recovers contours with an upper bound on the approximation error.

Robust economic order quantity models

In this paper, we study the classical economic order quantity (EOQ) model under significant. In particular, the problem under consideration is the economic order quantity model with the input data of the demand rate, the order cost, and the holding cost rate being uncertain. A robustness approach based on scenario characterization of the input data is adopted to describe the uncertainties. The aim of the approach is to find an inventory policy that performs well under all realizable input data scenarios. An efficient linear time algorithm is devised to find the robust decisions. Analytical results are obtained for the case where input data are defined in continuous intervals. Comparisons on performances between the robust decisions and the stochastic optimization decisions are conducted. The results demonstrate the advantages of robustness approach.

Proof of a fundamental result in self-similar traffic modeling

We state and prove the following key mathematical result in self-similar traffic modeling: the superposition of many ON/OFF sources (also known as packet trains ) with strictly alternating ON - and OFF -periods and whose ON -periods or OFF -periods exhibit the Noah Effect (i.e., have high variability or infinite variance) can produce aggregate network traffic that exhibits the Joseph Effect (i.e., is self-similar or long-range dependent). There is, moreover, a simple relation between the parameters describing the intensities of the Noah Effect (high variability) and the Joseph Effect (self-similarity). This provides a simple physical explanation for the presence of self-similar traffic patterns in modern high-speed network traffic that is consistent with traffic measurements at the source level. We illustrate how this mathematical result can be combined with modern high-performance computing capabilities to yield a simple and efficient linear-time algorithm for generating self-similar traffic traces.We also show how to obtain in the limit a Lévy stable motion, that is, a process with stationary and independent increments but with infinite variance marginals. While we have presently no empirical evidence that such a limit is consistent with measured network traffic, the result might prove relevant for some future networking scenarios.

Two recognizable string-matching problems over free partially commutative monoids

The two string-matching problems over free partially commutative monoids are studied and analyzed in detail in order to present efficient linear-time algorithms for solving these two problems over a constant-size alphabet.

A Statistical Study of the Performance of a Task Scheduling Algorithm

In this note we report the results of an experimental investigation on the performance of the very simple level scheduling algorithm for unit time task systems. Although the problem of the construction of optimal k-processor schedules for unit time tasks is NP-complete, the experimental study suggests that this efficient linear time algorithm can produce optimal schedules most of the time in the sense that the probability of producing an optimal schedule using this efficient linear time algorithm is at least 0.9 for over 700 cases randomly constructed in our experiment.