scholarly journals Finding and Counting Permutations via CSPs

Algorithmica ◽  
2021 ◽  
Author(s):  
Benjamin Aram Berendsohn ◽  
László Kozma ◽  
Dániel Marx
Keyword(s):  
Constraint Satisfaction ◽  
Polynomial Space ◽  
Permutation Patterns ◽  
Counting Problem ◽  
Exponential Time ◽  
Running Time ◽  
Algorithmic Question ◽  
Stack Sorting ◽  
Exponential Time Algorithms ◽  
New Algorithms

AbstractPermutation patterns and pattern avoidance have been intensively studied in combinatorics and computer science, going back at least to the seminal work of Knuth on stack-sorting (1968). Perhaps the most natural algorithmic question in this area is deciding whether a given permutation of length n contains a given pattern of length k. In this work we give two new algorithms for this well-studied problem, one whose running time is $$n^{k/4 + o(k)}$$ n k / 4 + o ( k ) , and a polynomial-space algorithm whose running time is the better of $$O(1.6181^n)$$ O ( 1 . 6181 n ) and $$O(n^{k/2 + 1})$$ O ( n k / 2 + 1 ) . These results improve the earlier best bounds of $$n^{0.47k + o(k)}$$ n 0.47 k + o ( k ) and $$O(1.79^n)$$ O ( 1 . 79 n ) due to Ahal and Rabinovich (2000) resp. Bruner and Lackner (2012) and are the fastest algorithms for the problem when $$k \in \varOmega (\log {n})$$ k ∈ Ω ( log n ) . We show that both our new algorithms and the previous exponential-time algorithms in the literature can be viewed through the unifying lens of constraint-satisfaction. Our algorithms can also count, within the same running time, the number of occurrences of a pattern. We show that this result is close to optimal: solving the counting problem in time $$f(k) \cdot n^{o(k/\log {k})}$$ f ( k ) · n o ( k / log k ) would contradict the exponential-time hypothesis (ETH). For some special classes of patterns we obtain improved running times. We further prove that 3-increasing (4321-avoiding) and 3-decreasing (1234-avoiding) permutations can, in some sense, embed arbitrary permutations of almost linear length, which indicates that a sub-exponential running time is unlikely with the current techniques, even for patterns from these restricted classes.

APPROXIMATING ASYMMETRIC TSP IN EXPONENTIAL TIME

2014 ◽  
Vol 25 (01) ◽  
pp. 89-99 ◽  
Author(s):  
ALEXANDER GOLOVNEV
Keyword(s):  
Traveling Salesman Problem ◽  
Directed Graph ◽  
Short Note ◽  
Simple Algorithm ◽  
Computable Function ◽  
Traveling Salesman ◽  
Polynomial Space ◽  
Exponential Time ◽  
Running Time ◽  
Polynomial Factor

Let G be a complete directed graph with n vertices and integer edge weights in range [0,M]. It is well known that an optimal Traveling Salesman Problem (TSP) in G can be solved in 2n time and space (all bounds are given within a polynomial factor of the input length, i.e., poly(n, log M)) and this is still the fastest known algorithm. If we allow a polynomial space only, then the best known algorithm has running time 4nnlog n. For TSP with bounded weights there is an algorithm with 1.657n · M running time. It is a big challenge to develop an algorithm with 2n time and polynomial space. Also, it is well-known that TSP cannot be approximated within any polynomial time computable function unless P=NP. In this short note we propose a very simple algorithm that, for any 0 < ε < 1, finds (1+ε)-approximation to asymmetric TSP in 2nε−1 time and ε−1 · poly(n, log M) space. Thereby, for any fixed ε, the algorithm needs 2n steps and polynomial space to compute (1 + ε)-approximation.

scholarly journals New Algorithms for Mixed Dominating Set

2021 ◽  
Vol vol. 23 no. 1 (Discrete Algorithms) ◽  
Author(s):  
Louis Dublois ◽  
Michael Lampis ◽  
Vangelis Th. Paschos
Keyword(s):  
Lower Bound ◽  
Dominating Set ◽  
Exact Algorithm ◽  
Polynomial Space ◽  
Parameterized Algorithms ◽  
Exponential Time ◽  
Open Questions ◽  
Fpt Algorithm ◽  
Exponential Space ◽  
New Algorithms

A mixed dominating set is a collection of vertices and edges that dominates all vertices and edges of a graph. We study the complexity of exact and parameterized algorithms for \textsc{Mixed Dominating Set}, resolving some open questions. In particular, we settle the problem's complexity parameterized by treewidth and pathwidth by giving an algorithm running in time $O^*(5^{tw})$ (improving the current best $O^*(6^{tw})$), as well as a lower bound showing that our algorithm cannot be improved under the Strong Exponential Time Hypothesis (SETH), even if parameterized by pathwidth (improving a lower bound of $O^*((2 - \varepsilon)^{pw})$). Furthermore, by using a simple but so far overlooked observation on the structure of minimal solutions, we obtain branching algorithms which improve both the best known FPT algorithm for this problem, from $O^*(4.172^k)$ to $O^*(3.510^k)$, and the best known exponential-time exact algorithm, from $O^*(2^n)$ and exponential space, to $O^*(1.912^n)$ and polynomial space. Comment: This paper has been accepted to IPEC 2020

scholarly journals The Complexity of Malign Ensembles

1990 ◽  
Vol 19 (335) ◽  
Author(s):  
Peter Bro Miltersen
Keyword(s):  
Polynomial Time ◽  
Upper Bounds ◽  
Lower And Upper Bounds ◽  
Worst Case ◽  
Average Case ◽  
Exponential Time ◽  
Running Time ◽  
Exponential Time Algorithms

We analyze the concept of <em> malignness</em>, which is the property of probability ensembles of making the average case running time equal to the worst case running time for a class of algorithms. We derive lower and upper bounds on the complexity of malign ensembles, which are tight for exponential time algorithms, and which show that no polynomial time computable malign ensemble exists for the class of superlinear algorithms. Furthermore, we show that for no class of superlinear algorithms a polynomial time computable malign ensemble exists, unless every language in P has an expected polynomial time constructor.

scholarly journals Finding Points in General Position

2017 ◽  
Vol 27 (04) ◽  
pp. 277-296 ◽  
Author(s):  
Vincent Froese ◽  
Iyad Kanj ◽  
André Nichterlein ◽  
Rolf Niedermeier
Keyword(s):  
Lower Bound ◽  
General Position ◽  
Subset Selection ◽  
Selection Problem ◽  
Fixed Parameter Tractability ◽  
Maximum Cardinality ◽  
Exponential Time ◽  
Running Time ◽  
Fixed Parameter ◽  
Set Of Points

We study the General Position Subset Selection problem: Given a set of points in the plane, find a maximum-cardinality subset of points in general position. We prove that General Position Subset Selection is NP-hard, APX-hard, and present several fixed-parameter tractability results for the problem as well as a subexponential running time lower bound based on the Exponential Time Hypothesis.

SIMULATED ANNEALING AND TABU SEARCH ALGORITHMS FOR MULTIWAY GRAPH PARTITION

1992 ◽  
Vol 02 (02) ◽  
pp. 159-185 ◽  
Author(s):  
L. TAO ◽  
Y.C. ZHAO ◽  
K. THULASIRAMAN ◽  
M.N.S. SWAMY
Keyword(s):  
Experimental Study ◽  
Simulated Annealing ◽  
Tabu Search ◽  
Time Frame ◽  
Search Algorithms ◽  
Graph Partition ◽  
Solution Quality ◽  
Running Time ◽  
New Algorithms

For a given graph G with vertex and edge weights, we partition the vertices into subsets to minimize the total weights for edges crossing the subsets (weighted cut size) under the constraint that the vertex weights are evenly distributed among the subsets. We propose two new effective graph partition algorithms based on simulated annealing and tabu search, and compare their performance with that of the LPK algorithm reported in Ref. 12. Extensive experimental study shows that both of our new algorithms produce significantly better solutions than the LPK algorithm (maximal and minimal improvements on average weighted cut size are roughly 51.8% and 10.5% respectively) with longer running time, and this advantage in solution quality would not change even if we run the LPK algorithm repeatedly with random initial solutions in the same time frame as required by our algorithms.

Modular lazy search for Constraint Satisfaction Problems

2001 ◽  
Vol 11 (5) ◽  
pp. 557-587 ◽  
Author(s):  
THOMAS NORDIN ◽  
ANDREW TOLMACH
Keyword(s):  
Constraint Satisfaction ◽  
Search Algorithms ◽  
General Purpose ◽  
Constant Factor ◽  
Constraint Satisfaction Problems ◽  
Combinatorial Search ◽  
Intermediate Data ◽  
Variable Ordering ◽  
New Algorithms ◽  
Simple Search

We describe a unified, lazy, declarative framework for solving constraint satisfaction problems, an important subclass of combinatorial search problems. These problems are both practically significant and computationally hard. Finding solutions involves combining good general-purpose search algorithms with problem-specific heuristics. Conventional imperative algorithms are usually implemented and presented monolithically, which makes them hard to understand and reuse, even though new algorithms often are combinations of simpler ones. Lazy functional languages, such as Haskell, encourage modular structuring of search algorithms by separating the generation and testing of potential solutions into distinct functions communicating through an explicit, lazy intermediate data structure. But only relatively simple search algorithms have been treated this way in the past. Our framework uses a generic generation and pruning algorithm parameterized by a labeling function that annotates search trees with conflict sets. We show that many advanced imperative search algorithms, including conflict-directed backjumping, backmarking, minimal forward checking, and fail-first dynamic variable ordering, can be obtained by suitable instantiation of the labeling function. More importantly, arbitrary combinations of these algorithms can be built by simply composing their labeling functions. Our modular algorithms are as efficient as the monolithic imperative algorithms in the sense that they make the same number of consistency checks, and most of our algorithms are within a constant factor of their imperative counterparts in runtime and space usage. We believe our framework is especially well-suited for experimenting to find good combinations of algorithms for specific problems.

scholarly journals Application of Algorithmic Manifold to Exponential Time

2017 ◽  
Author(s):  
Takuya Yabu
Keyword(s):  
Turing Machine ◽  
Turing Machines ◽  
Topological Properties ◽  
Exponential Time ◽  
Polynomial Time Algorithms ◽  
Exponential Time Algorithms ◽  
Deterministic Turing Machine ◽  
The Relationship ◽  
Np Problem ◽  
Machine Problem

In the previous paper, I defined algorithmic manifolds simulating polynomial-time algorithms, and I showed topological properties for P problem and NP problem and that NP problem can be transformed into deterministic Turing machine problem.　In this paper, I define algorithmic manifolds simulating exponential-time algorithms and, I show topological properties for EXPTIME problem and NEXPTIME problem. I also discuss the relationship between NEXPTIME and deterministic Turing machines.

Sign in / Sign up

Export Citation Format

Share Document