Automated Generation of Search Tree Algorithms for Graph Modification Problems

2003 ◽  
pp. 642-653 ◽  
Author(s):  
Jens Gramm ◽  
Jiong Guo ◽  
Falk Hüffner ◽  
Rolf Niedermeier
Keyword(s):  
Search Tree ◽  
Graph Modification ◽  
Automated Generation ◽  
Tree Algorithms ◽  
Graph Modification Problems

Automated Generation of Search Tree Algorithms for Hard Graph Modification Problems

Algorithmica ◽  
2004 ◽  
Vol 39 (4) ◽  
pp. 321-347 ◽  
Author(s):  
Jens Gramm ◽  
Jiong Guo ◽  
Falk Hüffner ◽  
Rolf Niedermeier
Keyword(s):  
Search Tree ◽  
Graph Modification ◽  
Automated Generation ◽  
Tree Algorithms ◽  
Graph Modification Problems

scholarly journals Polynomial kernels for 3-leaf power graph modification problems

2010 ◽  
Vol 158 (16) ◽  
pp. 1732-1744 ◽  
Author(s):  
Stéphane Bessy ◽  
Christophe Paul ◽  
Anthony Perez
Keyword(s):  
Graph Modification ◽  
Power Graph ◽  
Graph Modification Problems ◽  
Polynomial Kernels

scholarly journals An Improved Lock-Free Binary Search Tree

2019 ◽  
Author(s):  
Nicholas Whitlock ◽  
José C. Luís ◽  
Sam Shannon ◽  
Mark Alano ◽  
COP 4520
Keyword(s):  
Search Tree ◽  
Binary Search ◽  
Binary Search Tree ◽  
Performance Loss ◽  
Tree Algorithms ◽  
Tree Data ◽  
Software Engineers ◽  
The Many ◽  
Progression Factor ◽  
Tree Data Structure

We investigated the binary search tree data structure proposed in the publication, Efficient Lock-Free Binary Search Trees by Bapi Chatterjee, Nhan Nguyen and Philipas Tsigas. We will explore its correctness, progression factor, and the linearizability of its operations and report our findings. With a lock-free algorithm, software engineers will be able to use a thread-safe binary search tree that is capable of the many different operations that are normally available on a binary search tree. This includes the basic, primitive operations of Add(), Contains(), and Remove(), without the performance loss of using a binary search tree that uses object locking. An implementation of a binary search tree that uses locks to promote thread-safety takes a performance loss due to the threads waiting when another thread holds the lock and causing contention. The approach outlined in the aforementioned paper claims to have several key fundamental improvements over existing lock-free binary search tree algorithms. This implementation of the binary search tree eliminates contention in Contains() operations where, if a node was modified while a Contains() operation took place, the program would restart any current operation from the root of the tree. This happens because the thread can no longer reliably confide in the traversal of the tree and must restart its search. This is taxing to the performance of a binary search tree and an inefficient design can underperform a sequential implementation. Among other improvements, the authors of this paper claim that their algorithm is linearizable and has improved disjoint-access parallelism compared to similar existing algorithms.

BOUNDED SEARCH TREE ALGORITHMS FOR PARAMETRIZED COGRAPH DELETION: EFFICIENT BRANCHING RULES BY EXPLOITING STRUCTURES OF SPECIAL GRAPH CLASSES

2012 ◽  
Vol 04 (01) ◽  
pp. 1250008 ◽  
Author(s):  
JAMES NASTOS ◽  
YONG GAO
Keyword(s):  
Search Tree ◽  
Complex Case ◽  
Edge Deletion ◽  
Exponential Factor ◽  
Sparse Graphs ◽  
Graph Classes ◽  
Branching Rules ◽  
Fixed Parameter ◽  
Graph Class ◽  
Tree Algorithms

Many fixed-parameter tractable algorithms using a bounded search tree have been repeatedly improved, often by describing a larger number of branching rules involving an increasingly complex case analysis. We introduce a novel and general search strategy that branches on the forbidden subgraphs of a graph class relaxation. By using the class of P4-sparse graphs as the relaxed graph class, we obtain efficient bounded search tree algorithms for several parametrized deletion problems. We give the first non-trivial bounded search tree algorithms for the cograph edge-deletion problem and the trivially perfect edge-deletion problems. For the cograph vertex deletion problem, a refined analysis of the runtime of our simple bounded search algorithm gives a faster exponential factor than those algorithms designed with the help of complicated case distinctions and non-trivial running time analysis [R. Niedermeier and P. Rossmanith, An efficient fixed-parameter algorithm for 3-hitting set, J. Discrete Algorithms1(1) (2003) 89–102] and computer-aided branching rules [J. Gramm, J. Guo, F. Hüffner and R. Niedermeier, Automated generation of search tree algorithms for hard graph modification problems, Algorithmica39(4) (2004) 321–347].

Sign in / Sign up

Export Citation Format

Share Document