Maximum gap labelings of graphs

The Disjoint Connecting Paths problem and its capacitated generalization, called Unsplittable Flow problem, play an important role in practical applications such as communication network design and routing. These tasks are NP-hard in general, but various polynomial-time approximations are known. Nevertheless, the approximations tend to be either too loose (allowing large deviation from the optimum), or too complicated, often rendering them impractical in large, complex networks. Therefore, our goal is to present a solution that provides a relatively simple, efficient algorithm for the unsplittable flow problem in large directed graphs, where the task is NP-hard, and is known to remain NP-hard even to approximate up to a large factor. The efficiency of our algorithm is achieved by sacrificing a small part of the solution space. This also represents a novel paradigm for approximation. Rather than giving up the search for an exact solution, we restrict the solution space to a subset that is the most important for applications, and excludes only a small part that is marginal in some well-defined sense. Specifically, the sacrificed part only contains scenarios where some edges are very close to saturation. Since nearly saturated links are undesirable in practical applications, therefore, excluding near saturation is quite reasonable from the practical point of view. We refer the solutions that contain no nearly saturated edges as safe solutions, and call the approach safe approximation. We prove that this safe approximation can be carried out efficiently. That is, once we restrict ourselves to safe solutions, we can find the exact optimum by a randomized polynomial time algorithm.

A graceful labeling of a graph with q edges is a labeling of its vertices using the integers in [0, q], such that no two vertices are assigned the same label and each edge is uniquely identified by the absolute difference between the labels of its endpoints. The well known Graceful Tree Conjecture (GTC) states that all trees are graceful, and it remains open. It was proved in 1999 by Broersma and Hoede that there is an equivalent conjecture for GTC stating that all trees containing a perfect matching are strongly graceful (graceful with an extra condition). In this paper we extend the above result by showing that there exist infinitely many equivalent versions of the GTC. Moreover we verify these infinitely many equivalent conjectures of GTC for trees of diameter at most 7. Among others we are also able to identify new graceful trees and in particular generalize the ?-construction of Stanton-Zarnke (and later Koh- Rogers-Tan) for building graceful trees through two smaller given graceful trees.

Gathering a group of mobile agents is a fundamental task in the field of distributed and mobile systems. This can be made drastically more difficult to achieve when some agents are subject to faults, especially the Byzantine ones that are known as being the worst faults to handle. In this paper we study, from a deterministic point of view, the task of Byzantine gathering in a network modeled as a graph. In other words, despite the presence of Byzantine agents, all the other (good) agents, starting from {possibly} different nodes and applying the same deterministic algorithm, have to meet at the same node in finite time and stop moving. An adversary chooses the initial nodes of the agents (the number of agents may be larger than the number of nodes) and assigns a different positive integer (called label) to each of them. Initially, each agent knows its label. The agents move in synchronous rounds and can communicate with each other only when located at the same node. Within the team, f of the agents are Byzantine. A Byzantine agent acts in an unpredictable and arbitrary way. For example, it can choose an arbitrary port when it moves, can convey arbitrary information to other agents and can change its label in every round, in particular by forging the label of another agent or by creating a completely new one. Besides its label, which corresponds to a local knowledge, an agent is assigned some global knowledge denoted by GK that is common to all agents. In literature, the Byzantine gathering problem has been analyzed in arbitrary n-node graphs by considering the scenario when GK=(n,f) and the scenario when GK=f. In the first (resp. second) scenario, it has been shown that the minimum number of good agents guaranteeing deterministic gathering of all of them is f+1 (resp. f+2). However, for both these scenarios, all the existing deterministic algorithms, whether or not they are optimal in terms of required number of good agents, have the major disadvantage of having a time complexity that is exponential in n and L, where L is the value of the largest label belonging to a good agent. In this paper, we seek to design a deterministic solution for Byzantine gathering that makes a concession on the proportion of Byzantine agents within the team, but that offers a significantly lower complexity. We also seek to use a global knowledge whose the length of the binary representation (that we also call size) is small. In this respect, assuming that the agents are in a strong team i.e., a team in which the number of good agents is at least some prescribed value that is quadratic in f, we give positive and negative results. On the positive side, we show an algorithm that solves Byzantine gathering with all strong teams in all graphs of size at most n, for any integers n and f, in a time polynomial in n and the length |l_{min}| of the binary representation of the smallest label of a good agent. The algorithm works using a global knowledge of size O(log log log n), which is of optimal order of magnitude in our context to reach a time complexity that is polynomial in n and |l_{min}|. Indeed, on the negative side, we show that there is no deterministic algorithm solving Byzantine gathering with all strong teams, in all graphs of size at most n, in a time polynomial in n and |l_{min}| and using a global knowledge of size o(log log log n).

A randomized polynomial time algorithm is presented which, for every simple, connected, k-regular graph on n vertices, finds a tour that visits every vertex and has length at most (1 + √(64/1n k)) n with high probability. The proof follows simply from results developed in the context of permanents; Egorychev's and Falikman's theorem which lower bounds the permanent of a doubly stochastic matrix and the polynomial time algorithm of Jerrum, Sinclair and Vigoda which samples a near-random, perfect matching from a bipartite graph. The techniques in this paper suggest new permanent-based approaches for TSP which could be useful in attacking other interesting cases of TSP.

Let P be a set of n points in /spl Ropf//sup d/. For any 1/spl les/k/spl les/d, the outer k-radius of P, denoted by R/sub k/(P), is the minimum, over all (d-k) -dimensional fiats F, of max/sub p/spl isin/P/ d(p, F), where d(p, F) is the Euclidean distance between the point p and fiat F. We consider the scenario when the dimension d is not fixed and can be as large as n. Computing the various radii of point sets is a fundamental problem in computational convexity with many applications. The main result of this paper is a randomized polynomial time algorithm that approximates Rk (P) to within a factor of O/spl radic/(log n/spl middot/log d) for any 1/spl les/k/spl les/d. This algorithm is obtained using techniques from semidefinite programming and dimension reduction. Previously, good approximation algorithms were known only for the case k=1 and for the case when k=d-c for any constant c; there are polynomial time algorithms that approximate Rk(P) to within a factor of (1+/spl epsi/), for any /spl epsi/>0, when d-k is any fixed constant. On the other hand, some results from the mathematical programming community on approximating certain kinds of quadratic programs imply an O/spl radic/(log n) approximation for R/sub 1/ (P), the width of the point set P. We also prove an inapproximability result for computing Rk (P), which easily yields the conclusion that our approximation algorithm performs quite well for a large range of values of k. Our inapproximability result for Rk (P) improves the previous known hardness result of Brieden, and is proved by improving the parameters in Brieden's construction using basic ideas from PCP theory.

Graph labelling problem has been broadly studied for a long period for its applications, especially in frequency assignment in (mobile) communication system, X -ray crystallography, circuit design, etc. Nowadays, surjective L 2,1 -labelling is a well-studied problem. Motivated from the L 2,1 -labelling problem and the importance of surjective L 2,1 -labelling problem, we consider surjective L 2,1 -labelling ( SL 21 -labelling) problems for paths and interval graphs. For any graph G = V , E , an SL 21 -labelling is a mapping φ : V ⟶ 1,2 , … , n so that, for every pair of nodes u and v , if d u , v = 1 , then φ u − φ v ≥ 2 ; and if d u , v = 2 , then φ u − φ v ≥ 1 , and every label 1,2 , … , n is used exactly once, where d u , v represents the distance between the nodes u and v , and n is the number of nodes of graph G . In the present article, it is proved that any path P n can be surjectively L 2,1 -labelled if n ≥ 4 , and it is also proved that any interval graph IG G having n nodes and degree Δ > 2 can be surjectively L 2,1 -labelled if n = 3 Δ − 1 . Also, we have designed two efficient algorithms for surjective L 2,1 -labelling of paths and interval graphs. The results regarding both paths and interval graphs are the first result for surjective L 2,1 -labelling.

We explore a special case of rational identity testing and algorithmic versions of two theorems on noncommutative polynomials, namely, Amitsur's theorem [S.A Amitsur, 1966] and the Bresar-Klep theorem [Bresar and Klep, 2008] when the input polynomial is given by an algebraic branching program (ABP). Let f be a degree-d n-variate noncommutative polynomial in the free ring Q over rationals. 1) We consider the following special case of rational identity testing: Given a noncommutative ABP as white-box, whose edge labels are linear forms or inverses of linear forms, we show a deterministic polynomial-time algorithm to decide if the rational function computed by it is equivalent to zero in the free skew field Q . Given black-box access to the ABP, we give a deterministic quasi-polynomial time algorithm for this problem. 2) Amitsur's theorem implies that if a noncommutative polynomial f is nonzero on k x k matrices then, in fact, f(M_1,M_2,...,M_n) is invertible for some matrix tuple (M_1,M_2,...,M_n) in (M_k(ℚ))^n. While a randomized polynomial time algorithm to find such (M_1,M_2,...,M_n) given black-box access to f is simple, we obtain a deterministic s^{O(log d)} time algorithm for the problem with black-box access to f, where s is the minimum ABP size for f and d is the degree of f. 3) The Bresar-Klep Theorem states that the span of the range of any noncommutative polynomial f on k x k matrices over Q is one of the following: zero, scalar multiples of I_k, trace-zero matrices in M_k(Q), or all of M_k(Q). We obtain a deterministic polynomial-time algorithm to decide which case occurs, given white-box access to an ABP for f. We also give a deterministic s^{O(log d)} time algorithm given black-box access to an ABP of size s for f. Our algorithms work when k >= d. Our techniques are based on some automata theory combined with known techniques for noncommutative ABP identity testing [Ran Raz and Amir Shpilka, 2005; Michael A. Forbes and Amir Shpilka, 2013].

We consider several basic problems for texts and show that if the input texts are given by their Lempel-Ziv codes then the problems can be solved deterministically in polynomial time in the case when the original (uncompressed) texts are of exponential size. The growing importance of massively stored information requires new approaches to algorithms for compressed texts without decompressing. Denote by LZ(ω) the version of a string ω produced by Lempel-Ziv encoding algorithm. For given compressed strings LZ(T), LZ(P) we give the first known deterministic polynomial time algorithms to compute compressed representations of the set of all occurrences of the pattern P in T, all periods of T, all palindromes of T, and all squares of T. Then we consider several classical language recognition problems: We show that the first recognition problem has a polynomial time algorithm and the other two problems are NP-hard. We show also that the LZ encoding can be computed on-line in polynomial time delay and small space (i.e. proportional to the size of the compressed text). Also the compressed representation of a patternmatching automaton for the compressed pattern is computed in polynomial time.

A substitution theorem for graceful trees and its applications

Real World is filled with various hard and complex problems. One such complex problem is an optimization problem. Optimization has been an active area of research for several decades. Optimized solutions are hard to find so there are no deterministic algorithms that can find exact solution in polynomial time. In large domain of applications of intelligence techniques we are interested in exploring the application of Biographical Based Optimization (BBO) and Grey Wolf Optimizer (GWO) meta-heuristic algorithm to the domain of software testing. The GWO mimics the leadership hierarchy and hunting mechanism of grey wolves in nature. In this paper we adapt BBO and GWO for test suite prioritization and minimization and evaluate their performance with other nature inspired meta-heuristics.

We revisit a classical problem in computational geometry that has been studied since the 1980s: in the rectangle enclosure problem we want to report all k enclosing pairs of n input rectangles in 2D. We present the first deterministic algorithm that takes O(nlogn + k) worst-case time and O(n) space in the word-RAM model. This improves previous deterministic algorithms with O((nlogn + k)loglogn) running time. We achieve the result by derandomizing the algorithm of Chan, Larsen and Pătraşcu [SoCG’11] that attains the same time complexity but in expectation.The 2D rectangle enclosure problem is related to the offline dominance range reporting problem in 4D, and our result leads to the currently fastest deterministic algorithm for offline dominance reporting in any constant dimension d ≥ 4.A key tool behind Chan et al.’s previous randomized algorithm is shallow cuttings for 3D dominance ranges. Recently, Afshani and Tsakalidis [SODA’14] obtained a deterministic O(nlogn)-time algorithm to construct such cuttings. We first present an improved deterministic construction algorithm that runs in O(nloglogn) time in the word-RAM; this result is of independent interest. Many additional ideas are then incorporated, including a linear-time algorithm for merging shallow cuttings and an algorithm for an offline tree point location problem.KeywordsQuery PointDeterministic AlgorithmInput PointOuter CornerPlanar SeparatorThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Pseudorandom generators are constructed which convertO(SlogR) truly random bits toR bits that appear random to any algorithm that runs inSPACE(S). In particular, any randomized polynomial time algorithm that runs in spaceS can be simulated using onlyO(Slogn) random bits. An application of these generators is an explicit construction of universal traversal sequences (for arbitrary graphs) of lengthn O(logn). The generators constructed are technically stronger than just appearing random to spacebounded machines, and have several other applications. In particular, applications are given for “deterministic amplification” (i.e. reducing the probability of error of randomized algorithms), as well as generalizations of it.

Finite state automata are of fundamental importance in theory as well as applications in computer science. This dissertation presents several parallel algorithms for processing of them, including minimizing the number of states for a given finite state automaton, finding homing sequences for a given finite state automaton, converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. Implementation of some algorithms, as well as their experimental results, are also given. For minimization of deterministic finite automata, we present a parallel algorithm and discuss its implementation on a practical parallel machine using data parallel and message passing paradigms. Its time complexity on a p processor EREW PRAM $(p\\le n)$ for inputs of size n is $O({n\\log\\sp2n\\over p}+\\log n\\ \\log p)$ uniformly on almost all instances. The work done by our algorithm is thus within a factor of $O(\\log n)$ of the best known sequential algorithm. The space used by our algorithm is linear in the input size. The actual resource requirements of our implementations are consistent with these estimates. For finding homing sequences of deterministic finite automata, we present both deterministic and randomized algorithms. Two randomized algorithms of time complexity $O(log\\sp2n)$ are given. One of the randomized algorithms produces a homing sequence of length $O(n\\ log\\sp2n)$ for almost all DFA's with n states. The deterministic algorithm is based on a well known sequential algorithm. The implementation of the deterministic parallel algorithm shows that it can handle randomly generated instances with millions of states, and all DFA's with thousands of states using currently available parallel machines. Finally, we present an efficient parallel algorithm for converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. The resulting automaton is natural representation of a regular expression and has some important and practical uses in the document processing area. The time complexity of the algorithm is $O(\\log n)$ and the number of processors used is $O(n\\sp2).$

The selection problem, where one wishes to locate the k th smallest element in an unsorted array of size n, is one of the basic problems studied in computer science. The main focus of this work is designing algorithms for solving the selection problem in the presence of memory faults.Specifically, the computational model assumed here is a faulty variant of the RAM model (abbreviated as FRAM), which was introduced by Finocchi and Italiano [FI04].. In this model, the content of memory cells might get corrupted adversarially during the execution, and the algorithm cannot distinguish between corrupted cells and uncorrupted cells. The model assumes a constant number of reliable memory cells that never become corrupted, and an upper bound δ on the number of corruptions that may occur, which is given as an auxiliary input to the algorithm.The main contribution of this work is a deterministic resilient selection algorithm with optimal O(n) worst-case running time. Interestingly, the running time does not depend on the number of faults, and the algorithm does not need to know δ. As part of the solution, several techniques that allow to sometimes use non-tail recursion algorithms in the FRAM model are developed. Notice that using recursive algorithms in this model is problematic, as the stack might be too large to fit in reliable memory.The aforementioned resilient selection algorithm can be used to improve the complexity bounds for resilient k-d trees developed by Gieseke, Moruz and Vahrenhold [GMV10]. Specifically, the time complexity for constructing a k-d tree is improved from O(nlog2 n + δ 2) to O(n logn).Besides the deterministic algorithm, a randomized resilient selection algorithm is developed, which is simpler than the deterministic one, and has O(n + α) expected time complexity and O(1) space complexity (i.e., is in-place). This algorithm is used to develop the first resilient sorting algorithm that is in-place and achieves optimal O(nlogn + αδ) expected running time.KeywordsSelection ProblemRecursive CallSoft ErrorType ChildProgram CounterThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We consider the time and energy complexities of randomized leader election in a multiple-access channel, where the number of devices $n\geq 2$ is unknown. It is well-known that for polynomial-time randomized leader election algorithms with success probability $1-1/poly(n)$, the optimal energy complexity is $\Theta(\log\log^*n)$ if receivers can detect collisions, and $\Theta(\log^*n)$ otherwise. Without collision detection, all existing randomized leader election algorithms using $o(\log\log n)$ energy are Monte Carlo in that they may fail with some small probability, and they may consume unbounded energy and never halt when they fail. Though the optimal energy complexity of leader election appears to be settled, it is still an open question to attain the optimal $O(\log^*n)$ energy complexity by an efficient Las Vegas algorithm that never fails. In this paper we address this fundamental question. $\textbf{Separation between Monte Carlo and Las Vegas:}$ Without collision detection, we prove that any Las Vegas leader election algorithm with finite expected time complexity must use $\Omega(\log\log n)$ energy, establishing a large separation between Monte Carlo and Las Vegas algorithms. $\textbf{Exponential improvement with sender collision detection:}$ In the setting where senders can detect collisions, we design a new leader election algorithm that finishes in $O(\log^{1+\epsilon}n)$ time and uses $O(\epsilon^{-1}\log\log\log n)$ energy in expectation, showing that sender collision detection helps improve the energy complexity exponentially. $\textbf{Optimal deterministic leader election algorithm:}$ As a side result, via derandomization, we show a new deterministic algorithm that takes $O(n\log(N/n))$ time and $O(\log(N/n))$ energy to elect a leader from $n$ devices, where each device has a unique identifier in $[N]$. This algorithm is time-optimal and energy-optimal.