Judit Nagy-György

Online scheduling with machine cost and rejection

In this paper we define and investigate a new scheduling model. In this new model the number of machines is not fixed; the algorithm has to purchase the used machines, moreover the jobs can be rejected. We show that the simple combinations of the algorithms used in the area of scheduling with rejections and the area of scheduling with machine cost are not constant competitive. We present a 2.618-competitive algorithm called OPTCOPY.

Online File Caching with Rejection Penalties

In the file caching problem, the input is a sequence of requests for files out of a slow memory. A file has two attributes, a positive retrieval cost and an integer size. An algorithm is required to maintain a cache of size k such that the total size of files stored in the cache never exceeds k. Given a request for a file that is not present in the cache at the time of request, the file must be brought from the slow memory into the cache, possibly evicting other files from the cache. This incurs a cost equal to the retrieval cost of the requested file. Well-known special cases include paging (all costs and sizes are equal to 1), the cost model, which is also known as weighted paging, (all sizes are equal to 1), the fault model (all costs are equal to 1), and the bit model (the cost of a file is equal to its size). If bypassing is allowed, a miss for a file still results in an access to this file in the slow memory, but its subsequent insertion into the cache is optional.We study a new online variant of caching, called caching with rejection. In this variant, each request for a file has a rejection penalty associated with the request. The penalty of a request is given to the algorithm together with the request. When a file that is not present in the cache is requested, the algorithm must either bring the file into the cache, paying the retrieval cost of the file, or reject the file, paying the rejection penalty of the request. The objective function is the sum of total rejection penalty and the total retrieval cost. This problem generalizes both caching and caching with bypassing.We design deterministic and randomized algorithms for this problem. The competitive ratio of the randomized algorithm is O(logk), and this is optimal up to a constant factor. In the deterministic case, a k-competitive algorithm for caching, and a (k+1)-competitive algorithm for caching with bypassing are known. Moreover, these are the best possible competitive ratios. In contrast, we present a lower bound of 2k+1 on the competitive ratio of any deterministic algorithm for the variant with rejection. The lower bound is valid already for paging. We design a (2k+2)-competitive algorithm for caching with rejection. We also design a different (2k+1)-competitive algorithm, that can be used for paging and for caching in the bit and fault models.

On Nonpermutational Transformation Semigroups with an Application to Syntactic Complexity

We give an upper bound of nn-1!-n-3! for the possible largestsize of a subsemigroup of the full transformational semigroup overn elements consisting only of nonpermutational transformations.As an application we gain the same upper bound for the syntacticcomplexity of generalized definite languages as well.

Tight bounds for embedding bounded degree trees

Let T be a tree on n vertices with constant maximum degree K. Let G be a graph on n vertices having minimum degree δ(G) ≥ n/2 + ck log n, where CK is a constant. If n is sufficiently large then T ⊂ G. We also show that the bound on the minimum degree of G is tight.

Online hypergraph coloring with rejection

Abstract In this paper we investigate the online hypergraph coloring problem with rejection, where the algorithm is allowed to reject a vertex instead of coloring it but each vertex has a penalty which has to be paid if it is not colored. The goal is to minimize the sum of the number of the used colors for the accepted vertices and the total penalty paid for the rejected ones. We study the online problem which means that the algorithm receives the vertices of the hypergraph in some order v1, . . . , vn and it must decide about vi by only looking at the subhypergraph Hi = (Vi, Ei) where Vi = {v1, . . . , vi} and Ei contains the edges of the hypergraph which are subsets of Vi. We consider two models: in the full edge model only the edges where each vertex is accepted must be well-colored, in the trace model the subsets of the edges formed by the accepted vertices must be well colored as well. We consider proper and conflict free colorings. We present in each cases optimal online algorithms in the sense that they achieve asymptotically the smallest possible competitive ratio.

Biclique coverings, rectifier networks and the cost of ε-removal

We relate two complexity notions of bipartite graphs: the minimal weight biclique covering number Cov(G) and the minimal rectifier network size Rect(G) of a bipartite graph G. We show that there exist graphs with Cov(G) ≥ Rect(G)3/2 − e . As a corollary, we establish that there exist nondeterministic finite automata (NFAs) with e-transitions, having n transitions total such that the smallest equivalent e-free NFA has Ω(n 3/2 − e ) transitions. We also formulate a version of previous bounds for the weighted set cover problem and discuss its connections to giving upper bounds for the possible blow-up.

The online k-server problem with rejection

In this work we investigate the online k-server problem where each request has a penalty and it is allowed to reject the requests. The goal is to minimize the sum of the total distance moved by the servers and the total penalty of the rejected requests. We extend the work function algorithm to this more general model and prove that it is (4k-1)-competitive. We also consider the problem for special cases: we prove that the work function algorithm is 5-competitive if k=2 and (2k+1)-competitive for any k>=1 if the metric space is the line. In the case of the line we also present the extension of the double-coverage algorithm and prove that it is 3k-competitive. This algorithm has worse competitive ratio than the work function algorithm but it is much faster and memoryless. Moreover we prove that for any metric space containing at least k+1 points no online algorithm can have smaller competitive ratio than 2k+1, and this shows that the work function algorithm has the smallest possible competitive ratio in the case of lines and also in the case k=2.