2987495
Independent Sets in Circular-Arc Graphs
This paper presents a linear time algorithm for the independent set problem on circular-arc graphs. previous algorithms for this problem have assumed that the input is a set of circular-arcs and solve the problem in O(n) time. However, the fastest known algorithm for constructing the circular-are representation from a set of adjacency lists takes O(n2) time. We show that we can solve the problem in O(n + m) time, when we are given the circular-arc graph as a set of adjacency lists.
5208095
Decomposition of perfect graphs
Abstract We describe composition and decomposition schemes for perfect graphs, which generalize all recent results in this area, e.g., the amalgam and the 2-amalgam split. Our approach is based on the consideration of induced cycles and their complements in perfect graphs (as opposed to the consideration of cycles for defining biconnected or 3-connected graphs). Our notion of 1-inseparable graphs is “parallel” to that of biconnected graphs in that different edges in different inseparable components of a graph are not contained in any induced cycle or any complement of an induced cycle. Furthermore, in a special case which generalizes the join operation, this definition is self-complementary in a natural fashion. Our 2-composition operation, which only creates even induced cycles in the composed graphs, is based on two perfection-preserving vertex merge operations on perfect graphs. As a by-product, some new properties of minimally imperfect graphs are presented.
6232755
Algorithms for minimum covering by cliques and maximum clique in claw-free perfect graphs
An algorithm is given for determining a minimum cardinality clique cover ongraphs that do not contain claws, odd holes or odd anti-holes. These graphs are also shown to be perfect so that we obtain a new proof of the strong perfect graph theorem for claw-free graphs. A by-product of our analysis is an algorithm for determining a maximum cardinality clique on claw-free perfect graphs.
2164726
A New Planarity Test
Abstract Given an undirected graph, the planarity testing problem is to determine whether the graph can be drawn in a plane without any crossing edges. Linear time planarity testing algorithms have previously been designed by Hopcroft and Tarjan, and by Booth and Lueker. However, their approaches are quite involved. Several other approaches have also been developed for simplifying the planarity test. In this paper, we developed a very simple linear time testing algorithm based only on a depth-first search tree. When the given graph is not planar, our algorithm immediately produces explicit Kuratowski's subgraphs. A new data structure, PC -trees, is introduced, which can be viewed as abstract subembeddings of actual planar embeddings. A graph-reduction technique is adopted so that the embeddings for the planar biconnected components constructed at each iteration never have to be changed. The recognition and embedding are actually done simultaneously in our algorithm (Booth and Lueker, 1976). The implementation of our algorithm is quite straightforward.
17795095
A Simple Test for the Consecutive Ones Property
A (0,1)-matrix satisfies the consecutive ones property if there exists a column permutation such that the one's in each row of the resulting matrix are consecutive. Booth and Lueker [1976] designed a linear time testing algorithm for this property based on a data structure called “PQ-trees”. This procedure is very complicated and the linear time amortized analysis is also rather involved. We develop an off-line testing algorithm for the consecutive ones property without using PQ-trees. Our approach is based on a decomposition technique which separates the rows into “prime” subsets which admit unique column orderings that realize the consecutive ones property. The success of this approach is based on finding a good “row ordering” to be tested iteratively.
15536153
Applying Cilk in Provably Efficient Task Scheduling
We consider the application of Cilk, a C-based runtime system for multithreaded parallel programming, in scheduling static task graphs. We assume no pre-emption of task execution and no prior knowledge of the task execution times. Given a task graph G, the output of the scheduling algorithm is a Cilk program which, when executed, will initiate the tasks in a manner consistent with the precedence requirement of G. We rst report a restriction arising from the computational model of Cilk in task scheduling, in the sense that optimal scheduling may not be achievable with Cilk for certain task graphs. Luckily the restriction does not fundamentally hinder the practical application of the Cilk tool, as we next show that it is possible to quickly produce a reasonably good quality schedule in the sense of expected execution time. Given a task graph, our algorithm partitions the task nodes into subsets called bundles. Each bundle is mapped into a Cilk procedure. The output program then consists of a series of such Cilk procedures. By using Tarjan's disjoint-set algorithm for handling the bundles, we demonstrate that the parallel schedule can be derived in O(n + e) time for all practical purposes, whereand e denote the number of nodes and edges in the task graph. We further show that, with P processors, the expected completion time for the scheduled tasks achieves a near-optimum of T P T 1 = P + 1:5T 1 , where T 1 denotes the work, i.e., the sequential execution time of all tasks, and T 1 denotes the critical path, i.e., the total execution time of all tasks lying on the longest dependency path. Our work represents a serious attempt to use Cilk to handle complicated types of concurrency.
32109322
RIBRA-An Error-Tolerant Algorithm for the NMR Backbone Assignment Problem
We develop an iterative relaxation algorithm, called RIBRA, for NMR protein backbone assignment. RIBRA applies nearest neighbor and weighted maximum independent set algorithms to solve the problem. To deal with noisy NMR spectral data, RIBRA is executed in an iterative fashion based on the quality of spectral peaks. We first produce spin system pairs using the spectral data without missing peaks, then the data group with one missing peak, and finally, the data group with two missing peaks. We test RIBRA on two real NMR datasets: hb-SBD and hbLBD, and perfect BMRB data (with 902 proteins) and four synthetic BMRB data which simulate four kinds of errors. The accuracy of RIBRA on hbSBD and hbLBD are 91.4% and 83.6%, respectively. The average accuracy of RIBRA on perfect BMRB datasets is 98.28%, and 98.28%, 95.61%, 98.16% and 96.28% on four kinds of synthetic datasets, respectively.
5367915
A Maximum Entropy Approach to Biomedical Named Entity Recognition
Machine learning approaches are frequently used to solve name entity (NE) recognition (NER). In this paper we propose a hybrid method that uses maximum entropy (ME) as the underlying machine learning method incorporated with dictionary-based and rule-based methods for post-processing. Simply using ME for NER, inaccurate boundary detection of NEs and misclassification may occur. Some NEs are partially recognized by ME. In the post-processing stage, we use dictionary-based and rule-based methods to extend boundary of partially recognized NEs and to adjust classification. We use GENIA corpus 3.01 to conduct 10-fold cross-verification experiments. To evaluate the performance, we consider the longest NE annotations. We evaluate our approach using standard precision (P), recall (R), and F-score, where F-score is defined as 2PR/(P+R). The precision, recall and F-score ([P, R, F]) of our ME module for overall 23 categories is [0.512, 0.538, 0.525], and after the post-processing the performance becomes [0.729, 0.711, 0.72] for [P, R, F]. For protein, DNA and RNA classes, our method achieves [P, R, F] of [0.77, 0.80, 0.785], [0.653, 0.748, 0.7], and [0.716, 0.788, 0.752], respectively. The post-processing stage significantly improves the performance of our ME-based NER module.
6036700
Functional Implementation Techniques for CPU Cache Memories
As the performance gap between processors and main memory continues to widen, increasingly aggressive implementations of cache memories are needed to bridge the gap. In this paper, we consider some of the issues that are involved in the implementation of highly optimized cache memories and survey the techniques that can be used to help achieve the increasingly stringent design targets and constraints of modern processors. In particular, we consider techniques that enable the cache to be accessed quickly and still achieve a good hit ratio. We also consider issues such as area cost and bandwidth requirements. Trace-driven simulations of a TPC-C-like workload and selected applications from the SPEC95 benchmark suite are used in the paper to compare the performance of some of the techniques.
17900842
Fast cache access with full-map block directory
There are two concurrent paths in a typical cache access -one through the data array and the other through the tag array. In most cases, the path through the tag array is significantly longer than that through the data array. In this paper, we propose a new scheme that exploits this imbalance in the tag and data paths to improve overall cache performance. Under this scheme, an additional tag directory, the full-map block directory, is used to provide an alternate tag path to speed up cache access for almost all the memory requests. This scheme is based on the observation that spatial locality exists on a cache line basis i.e. cache lines near one another tend to be referenced together. Performance evaluation using the TPC-C benchmark and the SPEC92 benchmark suite demonstrates that this scheme has the potential to improve overall system performance by more than 20%.