arXiv subjects

Andreas Wiese

Publications and source records attributed to Andreas Wiese.

At least 19 recordsLinked to original sources

arXiv2026

A Multi-Objective Approach to Curriculum-Based Course Timetabling with Continuity Across Semesters

We study a curriculum-based university course timetabling problem in which the preferences of two key stakeholder groups - lecturers and students - must be balanced while maintaining continuity across semesters in a weekly repeating timetable. While existing approaches typically rely on single-objective formulations or aggregate multiple objectives into a weighted sum, this can obscure the underlying trade-offs between conflicting stakeholder preferences. We therefore propose a multi-objective mixed-integer programming approach that explicitly separates lecturer and student objectives and incorporates timetable continuity by limiting the number of changes, called perturbations, in the time period assignments of selected courses relative to the corresponding semester of the previous academic year. To explore the resulting trade-offs, we develop a multi-objective solution approach based on the lexicographic $\varepsilon$-constraint method, enabling the computation of a representative set of solutions whose images, i.e., their vectors of objective values, cover different regions of the objective space. The approach is evaluated on real-world instances from the Straubing Campus of the Technical University of Munich. The computational results reveal a clear and consistent trade-off between lecturers' and students' objectives across all instances. Moreover, the number of allowed perturbations is identified as a key decision parameter: relaxing this constraint significantly improves timetable quality for both stakeholder groups, although diminishing returns are observed beyond certain thresholds. Overall, the proposed approach provides decision support by generating a diverse set of optimized timetables and enabling a transparent analysis of stakeholder trade-offs and continuity for the practical timetable planning process.

math.OC↗

arXiv2026

Improved Approximation Algorithms for Non-Preemptive Throughput Maximization

The (Non-Preemptive) Throughput Maximization problem is a natural and fundamental scheduling problem. We are given $n$ jobs, where each job $j$ is characterized by a processing time and a time window, contained in a global interval $[0,T)$, during which~$j$ can be scheduled. Our goal is to schedule the maximum possible number of jobs non-preemptively on a single machine, so that no two scheduled jobs are processed at the same time. This problem is known to be strongly NP-hard. The best-known approximation algorithm for it has an approximation ratio of $1/0.6448 + \varepsilon \approx 1.551 + \varepsilon$ [Im, Li, Moseley IPCO'17], improving on an earlier result in [Chuzhoy, Ostrovsky, Rabani FOCS'01]. In this paper we substantially improve the approximation factor for the problem to $4/3+\varepsilon$ for any constant~$\varepsilon>0$. Using pseudo-polynomial time $(nT)^{O(1)}$, we improve the factor even further to $5/4+\varepsilon$. Our results extend to the setting in which we are given an arbitrary number of (identical) machines.

cs.DS↗

arXiv2026

Approximation Schemes and Structural Barriers for the Two-Dimensional Knapsack Problem with Rotations

We study the two-dimensional (geometric) knapsack problem with rotations (2DKR), in which we are given a square knapsack and a set of rectangles with associated profits. The objective is to find a maximum profit subset of rectangles that can be packed without overlap in an axis-aligned manner, possibly by rotating some rectangles by $90^{\circ}$. The best-known polynomial time algorithm for the problem has an approximation ratio of $3/2+\epsilon$ for any constant $\epsilon>0$, with an improvement to $4/3+\epsilon$ in the cardinality case, due to G{\'a}lvez et al. (FOCS 2017, TALG 2021). Obtaining a PTAS for the problem, even in the cardinality case, has remained a major open question in the setting of multidimensional packing problems, as mentioned in the survey by Christensen et al. (Computer Science Review, 2017). In this paper, we present a PTAS for the cardinality case of 2DKR. In contrast to the setting without rotations, we show that there are $(1+\epsilon)$-approximate solutions in which all items are packed greedily inside a constant number of rectangular {\em containers}. Our result is based on a new resource contraction lemma, which might be of independent interest. In contrast, for the general weighted case, we prove that this simple type of packing is not sufficient to obtain a better approximation ratio than $1.5$. However, we break this structural barrier and design a $(1.497+\epsilon)$-approximation algorithm for 2DKR in the weighted case. Our arguments also improve the best-known approximation ratio for the (weighted) case {\em without rotations} to $13/7+\epsilon \approx 1.857+\epsilon$. Finally, we establish a lower bound of $n^{\Omega(1/\epsilon)}$ on the running time of any $(1+\epsilon)$-approximation algorithm for our problem with or without rotations -- even in the cardinality setting, assuming the $k$-\textsc{Sum} Conjecture.

cs.DS↗

arXiv2025

A $(2+\varepsilon)$-approximation algorithm for the general scheduling problem in quasipolynomial time

We study the general scheduling problem (GSP) which generalizes and unifies several well-studied preemptive single-machine scheduling problems, such as weighted flow time, weighted sum of completion time, and minimizing the total weight of tardy jobs. We are given a set of jobs with their processing times and release times and seek to compute a (possibly preemptive) schedule for them on one machine. Each job incurs a cost that depends on its completion time in the computed schedule, as given by a separate job-dependent cost function for each job, and our objective is to minimize the total resulting cost of all jobs. The best known result for GSP is a polynomial time $O(\log\log P)$-approximation algorithm [Bansal and Pruhs, FOCS 2010, SICOMP 2014]. We give a quasi-polynomial time $(2+\epsilon)$-approximation algorithm for GSP, assuming that the jobs' processing times are quasi-polynomially bounded integers. For the special case of the weighted tardiness objective, we even obtain an improved approximation ratio of $1+\epsilon$. For this case, no better result had been known than the mentioned $O(\log\log P)$-approximation for the general case of GSP. Our algorithms use a reduction to an auxiliary geometric covering problem. In contrast to a related reduction for the special case of weighted flow time [Rohwedder, Wiese, STOC 2021][Armbruster, Rohwedder, Wiese, STOC 2023] for GSP it seems no longer possible to establish a tree-like structure for the rectangles to guide an algorithm that solves this geometric problem. Despite the lack of structure due to the problem itself, we show that an optimal solution can be transformed into a near-optimal solution that has certain structural properties. Due to those we can guess a substantial part of the solution quickly and partition the remaining problem in an intricate way, such that we can independently solve each part recursively.

cs.DS↗

arXiv2025

Finding Possible Winners in Spatial Voting with Incomplete Information

We consider a spatial voting model where both candidates and voters are positioned in the $d$-dimensional Euclidean space, and each voter ranks candidates based on their proximity to the voter's ideal point. We focus on the scenario where the given information about the locations of the voters' ideal points is incomplete; for each dimension, only an interval of possible values is known. In this context, we investigate the computational complexity of determining the possible winners under positional scoring rules. Our results show that the possible winner problem in one dimension is solvable in polynomial time for all $k$-truncated voting rules with constant $k$. Moreover, for some scoring rules for which the possible winner problem is NP-complete, such as approval voting for any dimension or $k$-approval for $d \geq 2$ dimensions, we give an FPT algorithm parameterized by the number of candidates. Finally, we classify tractable and intractable settings of the weighted possible winner problem in one dimension, and resolve the computational complexity of the weighted case for all two-valued positional scoring rules when $d=1$.

cs.GT↗

arXiv2025

Multiplicative assignment with upgrades

We study a problem related to submodular function optimization and the exact matching problem for which we show a rather peculiar status: its natural LP-relaxation can have fractional optimal vertices, but there is always also an optimal integral vertex, which we can also compute in polynomial time. More specifically, we consider the multiplicative assignment problem with upgrades in which we are given a set of customers and suppliers and we seek to assign each customer to a different supplier. Each customer has a demand and each supplier has a regular and an upgraded cost for each unit demand provided to the respective assigned client. Our goal is to upgrade at most $k$ suppliers and to compute an assignment in order to minimize the total resulting cost. This can be cast as the problem to compute an optimal matching in a bipartite graph with the additional constraint that we must select $k$ edges from a certain group of edges, similar to selecting $k$ red edges in the exact matching problem. Also, selecting the suppliers to be upgraded corresponds to maximizing a submodular set function under a cardinality constraint. Our result yields an efficient LP-based algorithm to solve our problem optimally. In addition, we provide also a purely strongly polynomial-time algorithm for it. As an application, we obtain exact algorithms for the upgrading variant of the problem to schedule jobs on identical or uniformly related machines in order to minimize their sum of completion times, i.e., where we may upgrade up to $k$ jobs to reduce their respective processing times.

cs.DS↗

arXiv2025

On the Approximability of Unsplittable Flow on a Path with Time Windows

In the Time-Windows Unsplittable Flow on a Path problem (twUFP) we are given a resource whose available amount changes over a given time interval (modeled as the edge-capacities of a given path $G$) and a collection of tasks. Each task is characterized by a demand (of the considered resource), a profit, an integral processing time, and a time window. Our goal is to compute a maximum profit subset of tasks and schedule them non-preemptively within their respective time windows, such that the total demand of the tasks using each edge $e$ is at most the capacity of $e$. We prove that twUFP is $\mathsf{APX}$-hard which contrasts the setting of the problem without time windows, i.e., Unsplittable Flow on a Path (UFP), for which a PTAS was recently discovered [Grandoni, M\"omke, Wiese, STOC 2022]. Then, we present a quasi-polynomial-time $2+\varepsilon$ approximation for twUFP under resource augmentation. Our approximation ratio improves to $1+\varepsilon$ if all tasks' time windows are identical. Our $\mathsf{APX}$-hardness holds also for this special case and, hence, rules out such a PTAS (and even a QPTAS, unless $\mathsf{NP}\subseteq\mathrm{DTIME}(n^{\mathrm{poly}(\log n)})$) without resource augmentation.

cs.DS↗

arXiv2025

A simpler QPTAS for scheduling jobs with precedence constraints

We study the classical scheduling problem of minimizing the makespan of a set of unit size jobs with precedence constraints on parallel identical machines. Research on the problem dates back to the landmark paper by Graham from 1966 who showed that the simple List Scheduling algorithm is a $(2-\frac{1}{m})$-approximation. Interestingly, it is open whether the problem is NP-hard if $m=3$ which is one of the few remaining open problems in the seminal book by Garey and Johnson. Recently, quite some progress has been made for the setting that $m$ is a constant. In a break-through paper, Levey and Rothvoss presented a $(1+\epsilon)$-approximation with a running time of $n^{(\log n)^{O((m^{2}/\epsilon^{2})\log\log n)}}$[STOC 2016, SICOMP 2019] and this running time was improved to quasi-polynomial by Garg[ICALP 2018] and to even $n^{O_{m,\epsilon}(\log^{3}\log n)}$ by Li[SODA 2021]. These results use techniques like LP-hierarchies, conditioning on certain well-selected jobs, and abstractions like (partial) dyadic systems and virtually valid schedules. In this paper, we present a QPTAS for the problem which is arguably simpler than the previous algorithms. We just guess the positions of certain jobs in the optimal solution, recurse on a set of guessed subintervals, and fill in the remaining jobs with greedy routines. We believe that also our analysis is more accessible, in particular since we do not use (LP-)hierarchies or abstractions of the problem like the ones above, but we guess properties of the optimal solution directly.

cs.DS↗

arXiv2024

A Deadline-Aware Scheduler for Smart Factory using WiFi 6

A key strategy for making production in factories more efficient is to collect data about the functioning of machines, and dynamically adapt their working. Such smart factories have data packets with a mix of stringent and non-stringent deadlines with varying levels of importance that need to be delivered via a wireless network. However, the scheduling of packets in the wireless network is crucial to satisfy the deadlines. In this work, we propose a technique of utilizing IEEE 802.11ax, popularly known as WiFi 6, for such applications. IEEE 802.11ax has a few unique characteristics, such as specific configurations of dividing the channels into resource units (RU) for packet transmission and synchronized parallel transmissions. We model the problem of scheduling packets by assigning profit to each packet and then maximizing the sum of profits. We first show that this problem is strongly NP-Hard, and then propose an approximation algorithm with a 12-approximate algorithm. Our approximation algorithm uses a variant of local search to associate the right RU configuration to each packet and identify the duration of each parallel transmission. Finally, we extensively simulate different scenarios to show that our algorithm works better than other benchmarks.

cs.NI↗

arXiv2024

Scheduling on a Stochastic Number of Machines

We consider a new scheduling problem on parallel identical machines in which the number of machines is initially not known, but it follows a given probability distribution. Only after all jobs are assigned to a given number of bags, the actual number of machines is revealed. Subsequently, the jobs need to be assigned to the machines without splitting the bags. This is the stochastic version of a related problem introduced by Stein and Zhong [SODA 2018, TALG 2020] and it is, for example, motivated by bundling jobs that need to be scheduled by data centers. We present two PTASs for the stochastic setting, computing job-to-bag assignments that (i) minimize the expected maximum machine load and (ii) maximize the expected minimum machine load (like in the Santa Claus problem), respectively. The former result follows by careful enumeration combined with known PTASs. For the latter result, we introduce an intricate dynamic program that we apply to a suitably rounded instance.

cs.DS↗

arXiv2024

Approximation Schemes for Geometric Knapsack for Packing Spheres and Fat Objects

We study the geometric knapsack problem in which we are given a set of $d$-dimensional objects (each with associated profits) and the goal is to find the maximum profit subset that can be packed non-overlappingly into a given $d$-dimensional (unit hypercube) knapsack. Even if $d=2$ and all input objects are disks, this problem is known to be \textsf{NP}-hard [Demaine, Fekete, Lang, 2010]. In this paper, we give polynomial time $(1+\varepsilon)$-approximation algorithms for the following types of input objects in any constant dimension $d$: - disks and hyperspheres, - a class of fat convex polygons that generalizes regular $k$-gons for $k\ge 5$ (formally, polygons with a constant number of edges, whose lengths are in a bounded range, and in which each angle is strictly larger than $\pi/2$), - arbitrary fat convex objects that are sufficiently small compared to the knapsack. We remark that in our \textsf{PTAS} for disks and hyperspheres, we output the computed set of objects, but for a $O_\varepsilon(1)$ of them, we determine their coordinates only up to an exponentially small error. However, it is unclear whether there always exists a $(1+\varepsilon)$-approximate solution that uses only rational coordinates for the disks' centers. We leave this as an open problem that is related to well-studied geometric questions in the realm of circle packing.

cs.CG↗

arXiv2024

Approximating the Geometric Knapsack Problem in Near-Linear Time and Dynamically

An important goal in algorithm design is determining the best running time for solving a problem (approximately). For some problems, we know the optimal running time, assuming certain conditional lower bounds. In this work, we study the $d$-dimensional geometric knapsack problem where we are far from this level of understanding. We are given a set of weighted d-dimensional geometric items like squares, rectangles, or hypercubes and a knapsack which is a square or a (hyper-)cube. We want to select a subset of items that fit non-overlappingly inside the knapsack, maximizing the total profit of the packed items. We make a significant step towards determining the best running time for solving these problems approximately by presenting approximation algorithms with near-linear running times for any constant dimension d and any constant parameter $ε$. For (hyper)-cubes, we present a $(1+ε)$-approximation algorithm whose running time drastically improves upon the known $(1+ε)$-approximation algorithm which has a running time where the exponent of n depends exponentially on $1/ε$ and $d$. Moreover, we present a $(2+ε)$-approximation algorithm for rectangles in the setting without rotations and a $(17/9+ε)$-approximation algorithm if we allow rotations by 90 degrees. The best known polynomial time algorithms for these settings have approximation ratios of $17/9+ε$ and $1.5+ε$, respectively, and running times in which the exponent of n depends exponentially on $1/ε$. We also give dynamic algorithms with polylogarithmic query and update times and the same approximation guarantees as the algorithms above. Key to our results is a new family of structured packings which we call easily guessable packings. They are flexible enough to guarantee profitable solutions and structured enough so that we can compute these solutions quickly.

cs.DS↗

arXiv2024

On Approximation Schemes for Stabbing Rectilinear Polygons

We study the problem of stabbing rectilinear polygons, where we are given $n$ rectilinear polygons in the plane that we want to stab, i.e., we want to select horizontal line segments such that for each given rectilinear polygon there is a line segment that intersects two opposite (parallel) edges of it. Our goal is to find a set of line segments of minimum total length such that all polygons are stabbed. For the special case of rectangles, there is a $O(1)$-approximation algorithm and the problem is $\mathsf{NP}$-hard [Chan et al.]. Also, the problem admits a QPTAS [Eisenbrand et al.] and even a PTAS [Khan et al.]. However, the approximability for the setting of more general polygons, e.g., L-shapes or T-shapes, is completely open. In this paper, we characterize the conditions under which the problem admits a $(1+\varepsilon)$-approximation algorithm. We assume that each input polygon is composed of rectangles that are placed on top of each other such that, for each pair of adjacent edges between rectangles, one edge contains the other. We show that if all input polygons satisfy the hourglass condition, then the problem admits a QPTAS. In particular, it is thus unlikely that this case is $\mathsf{APX}$-hard. Furthermore, we show that there exists a PTAS if each input polygon is composed out of rectangles with a bounded range of widths. On the other hand, if the input polygons do not satisfy these conditions, we prove that the problem is $\mathsf{APX}$-hard, already if all input polygons have only eight edges. We remark that all polygons with fewer edges automatically satisfy the hourglass condition. On the other hand, for arbitrary rectilinear polygons we even show a lower bound of $Ω(\log n)$ for the possible approximation ratio, which implies that the best possible ratio is in $Θ(\log n)$ since the problem is a special case of Set Cover.

cs.CG↗

arXiv2023

A $(3+ε)$-approximation algorithm for the minimum sum of radii problem with outliers and extensions for generalized lower bounds

For a given set of points in a metric space and an integer $k$, we seek to partition the given points into $k$ clusters. For each computed cluster, one typically defines one point as the center of the cluster. A natural objective is to minimize the sum of the cluster center's radii, where we assign the smallest radius $r$ to each center such that each point in the cluster is at a distance of at most $r$ from the center. The best-known polynomial time approximation ratio for this problem is $3.389$. In the setting with outliers, i.e., we are given an integer $m$ and allow up to $m$ points that are not in any cluster, the best-known approximation factor is $12.365$. In this paper, we improve both approximation ratios to $3+ε$. Our algorithms are primal-dual algorithms that use fundamentally new ideas to compute solutions and to guarantee the claimed approximation ratios. For example, we replace the classical binary search to find the best value of a Lagrangian multiplier $λ$ by a primal-dual routine in which $λ$ is a variable that is raised. Also, we show that for each connected component due to almost tight dual constraints, we can find one single cluster that covers all its points and we bound its cost via a new primal-dual analysis. We remark that our approximation factor of $3+ε$ is a natural limit for the known approaches in the literature. Then, we extend our results to the setting of lower bounds. There are algorithms known for the case that for each point $i$ there is a lower bound $L_{i}$, stating that we need to assign at least $L_{i}$ clients to $i$ if $i$ is a cluster center. For this setting, there is a $ 3.83$ approximation if outliers are not allowed and a ${12.365}$-approximation with outliers. We improve both ratios to $3.5 + ε$ and, at the same time, generalize the type of allowed lower bounds.

cs.DS↗

arXiv2023

Simpler constant factor approximation algorithms for weighted flow time -- now for any $p$-norm

A prominent problem in scheduling theory is the weighted flow time problem on one machine. We are given a machine and a set of jobs, each of them characterized by a processing time, a release time, and a weight. The goal is to find a (possibly preemptive) schedule for the jobs in order to minimize the sum of the weighted flow times, where the flow time of a job is the time between its release time and its completion time. It had been a longstanding important open question to find a polynomial time $O(1)$-approximation algorithm for the problem and this was resolved in a recent line of work. These algorithms are quite complicated and involve for example a reduction to (geometric) covering problems, dynamic programs to solve those, and LP-rounding methods to reduce the running time to a polynomial in the input size. In this paper, we present a much simpler $(6+ε)$-approximation algorithm for the problem that does not use any of these reductions, but which works on the input jobs directly. It even generalizes directly to an $O(1)$-approximation algorithm for minimizing the $p$-norm of the jobs' flow times, for any $0 < p < \infty$ (the original problem setting corresponds to $p=1$). Prior to our work, for $p>1$ only a pseudopolynomial time $O(1)$-approximation algorithm was known for this variant, and no algorithm for $p<1$. For the same objective function, we present a very simple QPTAS for the setting of constantly many unrelated machines for $0 < p < \infty$ (and assuming quasi-polynomially bounded input data). It works in the cases with and without the possibility to migrate a job to a different machine. This is the first QPTAS for the problem if migrations are allowed, and it is arguably simpler than the known QPTAS for minimizing the weighted sum of the jobs' flow times without migration.

cs.DS↗

arXiv2023

Optimal Fully Dynamic $k$-Center Clustering for Adaptive and Oblivious Adversaries

In fully dynamic clustering problems, a clustering of a given data set in a metric space must be maintained while it is modified through insertions and deletions of individual points. In this paper, we resolve the complexity of fully dynamic $k$-center clustering against both adaptive and oblivious adversaries. Against oblivious adversaries, we present the first algorithm for fully dynamic $k$-center in an arbitrary metric space that maintains an optimal $(2+ε)$-approximation in $O(k \cdot \mathrm{polylog}(n,Δ))$ amortized update time. Here, $n$ is an upper bound on the number of active points at any time, and $Δ$ is the aspect ratio of the metric space. Previously, the best known amortized update time was $O(k^2\cdot \mathrm{polylog}(n,Δ))$, and is due to Chan, Gourqin, and Sozio (2018). Moreover, we demonstrate that our runtime is optimal up to $\mathrm{polylog}(n,Δ)$ factors. In fact, we prove that even offline algorithms for $k$-clustering tasks in arbitrary metric spaces, including $k$-medians, $k$-means, and $k$-center, must make at least $Ω(n k)$ distance queries to achieve any non-trivial approximation factor. This implies a lower bound of $Ω(k)$ which holds even for the insertions-only setting. We also show deterministic lower and upper bounds for adaptive adversaries, demonstrate that an update time sublinear in $k$ is possible against oblivious adversaries for metric spaces which admit locally sensitive hash functions (LSH) and give the first fully dynamic $O(1)$-approximation algorithms for the closely related $k$-sum-of-radii and $k$-sum-of-diameter problems.

cs.DS↗

arXiv2023

Online and Dynamic Algorithms for Geometric Set Cover and Hitting Set

Set cover and hitting set are fundamental problems in combinatorial optimization which are well-studied in the offline, online, and dynamic settings. We study the geometric versions of these problems and present new online and dynamic algorithms for them. In the online version of set cover (resp. hitting set), $m$ sets (resp.~$n$ points) are give $n$ points (resp.~$m$ sets) arrive online, one-by-one. In the dynamic versions, points (resp. sets) can arrive as well as depart. Our goal is to maintain a set cover (resp. hitting set), minimizing the size of the computed solution. For online set cover for (axis-parallel) squares of arbitrary sizes, we present a tight $O(\log n)$-competitive algorithm. In the same setting for hitting set, we provide a tight $O(\log N)$-competitive algorithm, assuming that all points have integral coordinates in $[0,N)^{2}$. No online algorithm had been known for either of these settings, not even for unit squares (apart from the known online algorithms for arbitrary set systems). For both dynamic set cover and hitting set with $d$-dimensional hyperrectangles, we obtain $(\log m)^{O(d)}$-approximation algorithms with $(\log m)^{O(d)}$ worst-case update time. This partially answers an open question posed by Chan et al. [SODA'22]. Previously, no dynamic algorithms with polylogarithmic update time were known even in the setting of squares (for either of these problems). Our main technical contributions are an \emph{extended quad-tree }approach and a \emph{frequency reduction} technique that reduces geometric set cover instances to instances of general set cover with bounded frequency.

cs.CG↗

arXiv2022

A PTAS for Minimizing Weighted Flow Time on a Single Machine

An important objective in scheduling literature is to minimize the sum of weighted flow times. We are given a set of jobs where each job is characterized by a release time, a processing time, and a weight. Our goal is to find a preemptive schedule on a single machine that minimizes the sum of the weighted flow times of the jobs, where the flow time of a job is the time between its completion time and its release time. The currently best known polynomial time algorithm for the problem is a (2+eps)-approximation by Rohwedder and Wiese [STOC 2021] which builds on the prior break-through result by Batra, Garg, and Kumar [FOCS 2018] who found the first pseudo-polynomial time constant factor approximation algorithm for the problem, and on the result by Feige, Kulkarni, and Li [SODA 2019] who turned the latter into a polynomial time algorithm. However, it remains open whether the problem admits a PTAS. We answer this question in the affirmative and present a polynomial time (1+eps)-approximation algorithm for weighted flow time on a single machine. We rely on a reduction of the problem to a geometric covering problem, which was introduced in the mentioned (2+eps)-approximation algorithm, losing a factor 1+eps in the approximation ratio. However, unlike that algorithm, we solve the resulting instances of this problem exactly, rather than losing a factor 2+eps. Key for this is to identify and exploit structural properties of instances of the geometric covering problem which arise in the reduction from weighted flow time.

cs.DS↗