arXiv subjects

Klaus Jansen

Publications and source records attributed to Klaus Jansen.

At least 37 records · Page 2Linked to original sources

arXiv2025

Exact and Approximate High-Multiplicity Scheduling on Identical Machines

Goemans and Rothvoss (SODA'14) gave a framework for solving problems which can be described as finding a point in int$.$cone$(P\cap\mathbb{Z}^N)\cap Q$, where $P,Q\subset\mathbb{R}^N$ are (bounded) polyhedra. The running time for solving such a problem is $enc(P)^{2^{O(N)}}enc(Q)^{O(1)}$. This framework can be used to solve various scheduling problems, but the encoding length $enc(P)$ usually involves large parameters like the makespan. We describe three tools to improve the framework: - Problem-specific preprocessing can be used to greatly reduce $enc(P)$. - By solving a certain LP relaxation and then using the classical result by Frank and Tardos (J. Comb. '87), we get a more compact encoding of $P$ in general. - A result by Jansen and Klein (SODA'17) makes the running time depend on the number of vertices of the integer hull of $P$. We provide a new bound for this number that is similar to the one by Berndt et al. (SOSA'21) but better for our setting. For example, applied to the scheduling problem $P||C_{\max}$, these tools improve the running time from $(\log(C_{\max}))^{2^{O(d)}}enc(I)^{O(1)}$ to the possibly much better $(\log(p_{\max}))^{2^{O(d)}}enc(I)^{O(1)}$. Here, $p_{\max}$ is the largest processing time, $d$ is the number of different processing times, $C_{\max}$ is the makespan and $enc(I)$ is the encoding length of the instance. On the complexity side, we use reductions from the literature to provide new parameterized lower bounds for $P||C_{\max}$. Finally, we show that the big open question asked by Mnich and van Bevern (Comput. Oper. Res. '18) whether $P||C_{\max}$ is FPT w.r.t. the number of job types $d$ has the same answer as the question whether $Q||C_{\max}$ is FPT w.r.t. the number of job and machine types $d+τ$ (all in high-multiplicity encoding). The same holds for objective $C_{\min}$.

cs.DS↗

arXiv2024

Structural Results for High-Multiplicity Scheduling on Uniform Machines

Parameterizing by the largest processing time $p_{max}$ and the number of different job processing times $d$, we propose a proximity technique for High-Multiplicity Scheduling on Uniform Machines for the objectives Makespan Minimization ($C_{max}$) and Santa Claus ($C_{min}$) to obtain new structural results for these problems. The novelty in our approach is that we deal with a fractional solution for only a sub-instance, where the sub-instance itself is not known a priori. While the construction and computation of the fractional solution -- in contrast to usual proximity techniques -- is not done in polynomial time, this also allows us to formulate a comparably strong and general proximity statement. Eventually, this allows us to reduce the number of jobs that need to be distributed to a polynomial in $p_{max}$ for each machine and job type, by preassigning jobs according to the fractional solution, essentially returning a bounded number (at most $O(p_{max}^{O(d^2)})$) of kernels, one for each (guessed) sub-instance. We can use our structural results to obtain an algorithm with running time is $p_{max}^{O(d^2)}poly|I|$, matching the best-known so far by Knop et al. (Oper. Res. Lett. '21). Moreover, we propose an $p_{max}^{O(d^2)} poly |I|$ time algorithm for Envy Minimization $C_{envy}$ in the High-Multiplicity Setting on Uniform Machines, showing that this problem is \textsc{fpt} in $p_{max}$. Eventually, we also propose a general mechanism to bound the largest coefficient in the Configuration ILP for so called \emph{Load Balancing Problems} by $(dp_{max})^{O(d)}$, which we hope to be of interest for the development of algorithms.

cs.DS↗

arXiv2024

FPT Algorithms using Minimal Parameters for a Generalized Version of Maximin Shares

We study the computational complexity of fairly allocating indivisible, mixed-manna items. For basic measures of fairness, this problem is hard in general. Thus, research has flourished concerning input classes where efficient algorithms exist, both for the purpose of establishing theoretical boundaries and for the purpose of designing practical algorithms for real-world instances. Notably, the paradigm of fixed-parameter tractability (FPT) has lead to new insights and improved algorithms for a variety of fair allocation problems; see, for example, Bleim et al. (IJCAI 16), Aziz et al. (AAAI 17), Bredereck et al. (EC 19) and Kulkarni et al. (EC 21). Our focus is the fairness measure maximin shares (MMS). Motivated by the general non-existence of MMS allocations, Aziz et al. (AAAI 17) studied optimal MMS allocations, namely solutions that achieve the best $α$-approximation for the maximin share value of every agent. These allocations are guaranteed to exist, prompting the important open question of whether optimal MMS allocations can be computed efficiently. We answer this question affirmatively by providing FPT algorithms to output optimal MMS allocations. Furthermore, our techniques extend to find allocations that optimize alternative objectives, such as minimizing the additive approximation, and maximizing some variants of global welfare. In fact, all our algorithms are designed for a more general MMS problem in machine scheduling. Here, each mixed-manna item (job) must be assigned to an agent (machine) and has a processing time and a deadline. We develop efficient algorithms running in FPT time. Formally, we present polynomial time algorithms w.r.t. the input size times some function dependent on the parameters that yield optimal maximin-value approximations (among others) when parameterized by a set of natural parameters

cs.DS↗

arXiv2023

The Power of Duality: Response Time Analysis meets Integer Programming

We study a mutually enriching connection between response time analysis in real-time systems and the mixing set problem. Thereby generalizing over known results we present a new approach to the computation of response times in fixed-priority uniprocessor real-time scheduling. We even allow that the tasks are delayed by some period-constrained release jitter. By studying a dual problem formulation of the decision problem as an integer linear program we show that worst-case response times can be computed by algorithmically exploiting a conditional reduction to an instance of the mixing set problem. In the important case of harmonic periods our new technique admits a near-quadratic algorithm to the exact computation of worst-case response times. We show that generally, a smaller utilization leads to more efficient algorithms even in fixed-priority scheduling. Worst-case response times can be understood as least fixed points to non-trivial fixed point equations and as such, our approach may also be used to solve suitable fixed point problems. Furthermore, we show that our technique can be reversed to solve the mixing set problem by computing worst-case response times to associated real-time scheduling task systems. Finally, we also apply our optimization technique to solve 4-block integer programs with simple objective functions.

cs.DS↗

arXiv2023

New Support Size Bounds for Integer Programming, Applied to Makespan Minimization on Uniformly Related Machines

Mixed-integer linear programming (MILP) is at the core of many advanced algorithms for solving fundamental problems in combinatorial optimization. The complexity of solving MILPs directly correlates with their support size, which is the minimum number of non-zero integer variables in an optimal solution. A hallmark result by Eisenbrand and Shmonin (Oper. Res. Lett., 2006) shows that any feasible integer linear program (ILP) has a solution with support size $s\leq 2m\cdot\log(4mΔ)$, where $m$ is the number of constraints, and $Δ$ is the largest coefficient in any constraint. Our main combinatorial result are improved support size bounds for ILPs. To improve granularity, we analyze for the largest $1$-norm $A_{\max}$ of any column of the constraint matrix, instead of $Δ$. We show a support size upper bound of $s\leq m\cdot(\log(3A_{\max})+\sqrt{\log(A_{\max})})$, by deriving a new bound on the -1 branch of the Lambert $\mathcal{W}$ function. Additionally, we provide a lower bound of $m\log(A_{\max})$, proving our result asymptotically optimal. Furthermore, we give support bounds of the form $s\leq 2m\cdot\log(1.46A_{\max})$. These improve upon the previously best constants by Aliev. et. al. (SIAM J. Optim., 2018), because all our upper bounds hold equally with $A_{\max}$ replaced by $\sqrt{m}Δ$. Using our combinatorial result, we obtain the fastest known approximation schemes (EPTAS) for the fundamental scheduling problem of makespan minimization of uniformly related machines ($Q\mid\mid C_{\max}$).

cs.DS↗

arXiv2023

Improved Algorithms for Monotone Moldable Job Scheduling using Compression and Convolution

In the moldable job scheduling problem one has to assign a set of $n$ jobs to $m$ machines, in order to minimize the time it takes to process all jobs. Each job is moldable, so it can be assigned not only to one but any number of the equal machines. We assume that the work of each job is monotone and that jobs can be placed non-contiguously. In this work we present a $(\frac 3 2 + ε)$-approximation algorithm with a worst-case runtime of ${O(n \log^2(\frac 1 ε+ \frac {\log (εm)} ε) + \frac{n}ε \log(\frac 1 ε) {\log (εm)})}$ when $m\le 16n$. This is an improvement over the best known algorithm of the same quality by a factor of $\frac 1 ε$ and several logarithmic dependencies. We complement this result with an improved FPTAS with running time $O(n \log^2(\frac 1 ε+ \frac {\log (εm)} ε))$ for instances with many machines $m> 8\frac n ε$. This yields a $\frac 3 2$-approximation with runtime $O(n \log^2(\log m))$ when $m>16n$. We achieve these results through one new core observation: In an approximation setting one does not need to consider all $m$ possible allotments for each job. We will show that we can reduce the number of relevant allotments for each job from $m$ to $O(\frac 1 ε+ \frac {\log (εm)}ε)$. Using this observation immediately yields the improved FPTAS. For the other result we use a reduction to the knapsack problem first introduced by Mounié, Rapine and Trystram. We use the reduced number of machines to give a new elaborate rounding scheme and define a modified version of this this knapsack instance. This in turn allows for the application of a convolution based algorithm by Axiotis and Tzamos. We further back our theoretical results through a practical implementation and compare our algorithm to the previously known best result.

cs.DS↗

arXiv2022

Solving Cut-Problems in Quadratic Time for Graphs With Bounded Treewidth

In the problem (Unweighted) Max-Cut we are given a graph $G = (V,E)$ and asked for a set $S \subseteq V$ such that the number of edges from $S$ to $V \setminus S$ is maximal. In this paper we consider an even harder problem: (Weighted) Max-Bisection. Here we are given an undirected graph $G = (V,E)$ and a weight function $w \colon E \to \mathbb Q_{>0}$ and the task is to find a set $S \subseteq V$ such that (i) the sum of the weights of edges from $S$ is maximal; and (ii) $S$ contains $\left\lceil{\frac{n}{2}}\right\rceil$ vertices (where $n = \lvert V\rvert$). We design a framework that allows to solve this problem in time $\mathcal O(2^t n^2)$ if a tree decomposition of width $t$ is given as part of the input. This improves the previously best running time for Max-Bisection of [DBLP:journals/tcs/HanakaKS21] by a factor $t^2$. Under common hardness assumptions, neither the dependence on $t$ in the exponent nor the dependence on $n$ can be reduced [DBLP:journals/tcs/HanakaKS21,DBLP:journals/jcss/EibenLM21,DBLP:journals/talg/LokshtanovMS18]. Our framework can be applied to other cut problems like Min-Edge-Expansion, Sparsest-Cut, Densest-Cut, $β$-Balanced-Min-Cut, and Min-Bisection. It also works in the setting with arbitrary weights and directed edges.

cs.DS↗

arXiv2022

On the Complexity of Scheduling Problems With a Fixed Number of Parallel Identical Machines

In parallel machine scheduling, we are given a set of jobs, together with a number of machines and our goal is to decide for each job, when and on which machine(s) it should be scheduled in order to minimize some objective function. Different machine models, job characteristics and objective functions result in a multitude of scheduling problems and many of them are NP-hard, even for a fixed number of identical machines. In this work, we give conditional running time lower bounds for a large number of scheduling problems, indicating the optimality of some classical algorithms. Most notably, we show that the algorithm by Lawler and Moore for $1||\sum w_jU_j$ and $Pm||C_{max}$, as well as the algorithm by Lee and Uzsoy for $P2||\sum w_jC_j$ are probably optimal. There is still small room for improvement for the $1|Rej\leq Q|\sum w_jU_j$ algorithm by Zhang et al., the algorithm for $1||\sum T_j$ by Lawler and the FPTAS for $1||\sum w_jU_j$ by Gens and Levner. We also give a lower bound for $P2|any|C_{max}$ and improve the dynamic program by Du and Leung from $\mathcal{O}(nP^2)$ to $\mathcal{O}(nP)$, matching this new lower bound. Here, $P$ is the sum of all processing times. The same idea also improves the algorithm for $P3|any|C_{max}$ by Du and Leung from $\mathcal{O}(nP^5)$ to $\mathcal{O}(nP^2)$. While our results suggest the optimality of some classical algorithms, they also motivate future research in cases where the best known algorithms do not quite match the lower bounds.

cs.DS↗

arXiv2022

Scheduling with Many Shared Resources

Consider the many shared resource scheduling problem where jobs have to be scheduled on identical parallel machines with the goal of minimizing the makespan. However, each job needs exactly one additional shared resource in order to be executed and hence prevents the execution of jobs that need the same resource while being processed. Previously a $(2m/(m+1))$-approximation was the best known result for this problem. Furthermore, a $6/5$-approximation for the case with only two machines was known as well as a PTAS for the case with a constant number of machines. We present a simple and fast 5/3-approximation and a much more involved but still reasonable 1.5-approximation. Furthermore, we provide a PTAS for the case with only a constant number of machines, which is arguably simpler and faster than the previously known one, as well as a PTAS with resource augmentation for the general case. The approximation schemes make use of the N-fold integer programming machinery, which has found more and more applications in the field of scheduling recently. It is plausible that the latter results can be improved and extended to more general cases. Lastly, we give a $5/4 - \varepsilon$ inapproximability result for the natural problem extension where each job may need up to a constant number (in particular $3$) of different resources.

cs.DS↗

arXiv2022

On Integer Programming, Discrepancy, and Convolution

Integer programs with m constraints are solvable in pseudo-polynomial time in $Δ$, the largest coefficient in a constraint, when m is a fixed constant. We give a new algorithm with a running time of $O(\sqrt{m}Δ)^{2m} + O(nm)$, which improves on the state-of-the-art. Moreover, we show that improving on our algorithm for any $m$ is equivalent to improving over the quadratic time algorithm for $(\min,~+)$-convolution. This is a strong evidence that our algorithm's running time is the best possible. We also present a specialized algorithm with running time $O(\sqrt{m} Δ)^{(1 + o(1))m} + O(nm)$ for testing feasibility of an integer program and also give a tight lower bound, which is based on the SETH in this case.

cs.DS↗

arXiv2022

A PTAS for Packing Hypercubes into a Knapsack

We study the d-dimensional hypercube knapsack problem where we are given a set of d-dimensional hypercubes with associated profits, and a knapsack which is a unit d-dimensional hypercube. The goal is to find an axis-aligned non-overlapping packing of a subset of hypercubes such that the profit of the packed hypercubes is maximized. For this problem, Harren (ICALP'06) gave an algorithm with an approximation ratio of (1+1/2^d+epsilon). For d=2, Jansen and Solis-Oba (IPCO'08) showed that the problem admits a polynomial-time approximation scheme (PTAS); Heydrich and Wiese (SODA'17) further improved the running time and gave an efficient polynomial-time approximation scheme (EPTAS). Both the results use structural properties of 2-D packing, which do not generalize to higher dimensions. For d>2, it remains open to obtain a PTAS, and in fact, there has been no improvement since Harren's result. We settle the problem by providing a PTAS. Our main technical contribution is a structural lemma which shows that any packing of hypercubes can be converted into another structured packing such that a high profitable subset of hypercubes is packed into a constant number of special hypercuboids, called V-Boxes and N-Boxes. As a side result, we give an almost optimal algorithm for a variant of the strip packing problem in higher dimensions. This might have applications for other multidimensional geometric packing problems.

cs.DS↗

arXiv2021

Load Balancing: The Long Road from Theory to Practice

There is a long history of approximation schemes for the problem of scheduling jobs on identical machines to minimize the makespan. Such a scheme grants a $(1+ε)$-approximation solution for every $ε> 0$, but the running time grows exponentially in $1/ε$. For a long time, these schemes seemed like a purely theoretical concept. Even solving instances for moderate values of $ε$ seemed completely illusional. In an effort to bridge theory and practice, we refine recent ILP techniques to develop the fastest known approximation scheme for this problem. An implementation of this algorithm reaches values of $ε$ lower than $2/11\approx 18.2\%$ within a reasonable timespan. This is the approximation guarantee of MULTIFIT, which, to the best of our knowledge, has the best proven guarantee of any non-scheme algorithm.

cs.DS↗

arXiv2021

Closing the gap for single resource constraint scheduling

In the problem called single resource constraint scheduling, we are given $m$ identical machines and a set of jobs, each needing one machine to be processed as well as a share of a limited renewable resource $R$. A schedule of these jobs is feasible if, at each point in the schedule, the number of machines and resources required by jobs processed at this time is not exceeded. It is NP-hard to approximate this problem with a ratio better than $3/2$. On the other hand, the best algorithm so far has an absolute approximation ratio of $2+\varepsilon$. This paper presents an algorithm with absolute approximation ratio~$(3/2+\varepsilon)$, which closes the gap between inapproximability and best algorithm except for a negligible small~$\varepsilon$.

cs.DS↗

arXiv2021

Peak Demand Minimization via Sliced Strip Packing

We study Nonpreemptive Peak Demand Minimization (NPDM) problem, where we are given a set of jobs, specified by their processing times and energy requirements. The goal is to schedule all jobs within a fixed time period such that the peak load (the maximum total energy requirement at any time) is minimized. This problem has recently received significant attention due to its relevance in smart-grids. Theoretically, the problem is related to the classical strip packing problem (SP). In SP, a given set of axis-aligned rectangles must be packed into a fixed-width strip, such that the height of the strip is minimized. NPDM can be modeled as strip packing with slicing and stacking constraint: each rectangle may be cut vertically into multiple slices and the slices may be packed into the strip as individual pieces. The stacking constraint forbids solutions where two slices of the same rectangle are intersected by the same vertical line. Nonpreemption enforces the slices to be placed in contiguous horizontal locations (but may be placed at different vertical locations). We obtain a $(5/3+ε)$-approximation algorithm for the problem. We also provide an asymptotic efficient polynomial-time approximation scheme (AEPTAS) which generates a schedule for almost all jobs with energy consumption $(1+ε)OPT$. The remaining jobs fit into a thin container of height $1$. The previous best for NPDM was 2.7 approximation based on FFDH [Ranjan et al. 2015]. One of our key ideas is providing several new lower bounds on the optimal solution of a geometric packing, which could be useful in other related problems. These lower bounds help us to obtain approximative solutions based on Steinberg's algorithm in many cases. In addition, we show how to split schedules generated by the AEPTAS into few segments and to rearrange the corresponding jobs to insert the thin container mentioned above.

cs.DS↗

arXiv2021

Robust Online Algorithms for Dynamic Choosing Problems

Semi-online algorithms that are allowed to perform a bounded amount of repacking achieve guaranteed good worst-case behaviour in a more realistic setting. Most of the previous works focused on minimization problems that aim to minimize some costs. In this work, we study maximization problems that aim to maximize their profit. We mostly focus on a class of problems that we call choosing problems, where a maximum profit subset of a set objects has to be maintained. Many known problems, such as Knapsack, MaximumIndependentSet and variations of these, are part of this class. We present a framework for choosing problems that allows us to transfer offline $α$-approximation algorithms into $(α-epsilon)$-competitive semi-online algorithms with amortized migration $O(1/ε)$. Moreover we complement these positive results with lower bounds that show that our results are tight in the sense that no amortized migration of $o(1/ε)$ is possible.

cs.DS↗

arXiv2021

Total Completion Time Minimization for Scheduling with Incompatibility Cliques

This paper considers parallel machine scheduling with incompatibilities between jobs. The jobs form a graph and no two jobs connected by an edge are allowed to be assigned to the same machine. In particular, we study the case where the graph is a collection of disjoint cliques. Scheduling with incompatibilities between jobs represents a well-established line of research in scheduling theory and the case of disjoint cliques has received increasing attention in recent years. While the research up to this point has been focused on the makespan objective, we broaden the scope and study the classical total completion time criterion. In the setting without incompatibilities, this objective is well known to admit polynomial time algorithms even for unrelated machines via matching techniques. We show that the introduction of incompatibility cliques results in a richer, more interesting picture. Scheduling on identical machines remains solvable in polynomial time, while scheduling on unrelated machines becomes APX-hard. Furthermore, we study the problem under the paradigm of fixed-parameter tractable algorithms (FPT). In particular, we consider a problem variant with assignment restrictions for the cliques rather than the jobs. We prove that it is NP-hard and can be solved in FPT time with respect to the number of cliques. Moreover, we show that the problem on unrelated machines can be solved in FPT time for reasonable parameters, e.g., the parameter pair: number of machines and maximum processing time. The latter result is a natural extension of known results for the case without incompatibilities and can even be extended to the case of total weighted completion time. All of the FPT results make use of n-fold Integer Programs that recently have received great attention by proving their usefulness for scheduling problems.

cs.CC↗

arXiv2021

The Double Exponential Runtime is Tight for 2-Stage Stochastic ILPs

We consider fundamental algorithmic number theoretic problems and their relation to a class of block structured Integer Linear Programs (ILPs) called $2$-stage stochastic. A $2$-stage stochastic ILP is an integer program of the form $\min \{c^T x \mid \mathcal{A} x = b, \ell \leq x \leq u, x \in \mathbb{Z}^{r + ns} \}$ where the constraint matrix $\mathcal{A} \in \mathbb{Z}^{nt \times r +ns}$ consists of $n$ matrices $A_i \in \mathbb{Z}^{t \times r}$ on the vertical line and $n$ matrices $B_i \in \mathbb{Z}^{t \times s}$ on the diagonal line aside. First, we show a stronger hardness result for a number theoretic problem called Quadratic Congruences where the objective is to compute a number $z \leq γ$ satisfying $z^2 \equiv α\bmod β$ for given $α, β, γ\in \mathbb{Z}$. This problem was proven to be NP-hard already in 1978 by Manders and Adleman. However, this hardness only applies for instances where the prime factorization of $β$ admits large multiplicities of each prime number. We circumvent this necessity proving that the problem remains NP-hard, even if each prime number only occurs constantly often. Then, using this new hardness result for the Quadratic Congruences problem, we prove a lower bound of $2^{2^{δ(s+t)}} |I|^{O(1)}$ for some $δ> 0$ for the running time of any algorithm solving $2$-stage stochastic ILPs assuming the Exponential Time Hypothesis (ETH). Here, $|I|$ is the encoding length of the instance. This result even holds if $r$, $||b||_{\infty}$, $||c||_{\infty}, ||\ell||_{\infty}$ and the largest absolute value $Δ$ in the constraint matrix $\mathcal{A}$ are constant. This shows that the state-of-the-art algorithms are nearly tight. Further, it proves the suspicion that these ILPs are indeed harder to solve than the closely related $n$-fold ILPs where the contraint matrix is the transpose of $\mathcal A$.

cs.CC↗

arXiv2020

Fuzzy Simultaneous Congruences

We introduce a very natural generalization of the well-known problem of simultaneous congruences. Instead of searching for a positive integer $s$ that is specified by $n$ fixed remainders modulo integer divisors $a_1,\dots,a_n$ we consider remainder intervals $R_1,\dots,R_n$ such that $s$ is feasible if and only if $s$ is congruent to $r_i$ modulo $a_i$ for some remainder $r_i$ in interval $R_i$ for all $i$. This problem is a special case of a 2-stage integer program with only two variables per constraint which is is closely related to directed Diophantine approximation as well as the mixing set problem. We give a hardness result showing that the problem is NP-hard in general. By investigating the case of harmonic divisors, i.e. $a_{i+1}/a_i$ is an integer for all $i<n$, which was heavily studied for the mixing set problem as well, we also answer a recent algorithmic question from the field of real-time systems. We present an algorithm to decide the feasibility of an instance in time $\mathcal{O}(n^2)$ and we show that if it exists even the smallest feasible solution can be computed in strongly polynomial time $\mathcal{O}(n^3)$.

cs.DM↗