Fixed-Parameter Algorithms for Unsplittable Flow Cover

Abstract

The Unsplittable Flow Cover problem (UFP-cover) models the well-studied general caching problem and various natural resource allocation settings. We are given a path with a demand on each edge and a set of tasks, each task being defined by a subpath and a size. The goal is to select a subset of the tasks of minimum cardinality such that on each edge e the total size of the selected tasks using e is at least the demand of e. There is a polynomial time 4-approximation for the problem (Bar-Noy et al. STOC 2001) and also a QPTAS (Höhn et al. ICALP 2018). In this paper we study fixed-parameter algorithms for the problem. We show that it is W[1]-hard but it becomes FPT if we can slighly violate the edge demands (resource augmentation) and also if there are at most k different task sizes. Then we present a parameterized approximation scheme (PAS), i.e., an algorithm with a running time of $f(k)\cdot n^{O_{\epsilon }(1)}$ that outputs a solution with at most (1 + 𝜖)k tasks or asserts that there is no solution with at most k tasks. In this algorithm we use a new trick that intuitively allows us to pretend that we can select tasks from OPT multiple times. We show that the other two algorithms extend also to the weighted case of the problem, at the expense of losing a factor of 1 + 𝜖 in the cost of the selected tasks.

Appendix : A: Reduction from Generalized Caching in the Fault Model

A reduction from generalized caching in the fault model to UFP-cover was given in [1, 5]. For completeness we present the reduction here using our notation. In the fault model of general caching we are given a value $M\in {\mathbb {N}}$ that denotes the size of the cache and we are given a set of pages $\mathcal {P}$. Each page $q\in \mathcal {P}$ has a (not necessarily unit) size $s(q)\in {\mathbb {N}}$. Also we are given a set of requests $\mathcal {R}$ where each request $j\in \mathcal {R}$ is characterized by a time t_j ≥ 0 and a page $q_{j} \in \mathcal {P}$ meaning that at time t_j the page q_j has to be present in the cache. The goal is to decide at what times we bring each page into the cache in order to minimize the total number of these transfers, assuming that initially the cache is empty. We show here how to reduce this problem to UFP-cover with unit weights.

Lemma 28

Given an instance $(\mathcal {P},\mathcal {R},M)$ of general caching in the fault model, in polynomial time we can compute an instance (V,E,T,u) of UFP-cover such that for any solution to $(\mathcal {P},\mathcal {R},M)$ with cost C, there is a solution $T^{\prime }\subseteq T$ to (V,E,T,u) with $|T^{\prime }|=C$, and vice versa.

Proof

W.l.o.g. we can restrict ourselves to solutions of $(\mathcal {P},\mathcal {R},M)$ where each page enters the cache only when it is requested and leaves the cache only right after it is requested, and to instances where each page is requested at least once and $M< {\sum }_{q\in \mathcal {P}} s(q)$. Thus, a solution is completely defined by deciding at each point in time whether we evict the page that was just requested or whether we keep it in the cache until it is requested again. We construct the path (V,E) by defining one edge e(t) for each time t such that there is a request $j\in \mathcal {R}$ with t_j = t, and ordering the edges on the path by increasing values of t. For defining the tasks T, we initialize T := ∅. Then, for every page $q\in \mathcal {P}$ and every pair j₁,j₂ ∈ R of consecutive requests of page q, we add a task i(j₁,j₂) to T with size $p_{i(j_{1},j_{2})} = s(q)$. The subpath $P_{i(j_{1},j_{2})}$ is the one that starts in the right vertex of $e(t_{j_{1}})$ and ends in the left vertex of $e(t_{j_{2}})$. We define the demand of the edge e(t) to be $u_{e(t)}= p(T_{e(t)}) - M + {\sum }_{j\in R: t_{j}=t} s(q_{j})$ for every time t. We also add an extra edge e₀ at the left of E with capacity $u_{e_{0}}={\sum }_{q\in \mathcal {P}} s(q)$ and we add a task $i^{*}_{q}$ with $P_{i^{*}_{q}}= \{e_{0}\}$ and $p_{i^{*}_{q}}= s(q)$ for each page $q\in \mathcal {P}$. The cost of these tasks is exactly the total cost of loading each page into the cache once, i.e., the first time that the respective page is requested.

Given a solution to $(\mathcal {P},\mathcal {R},M)$, we construct a solution $T^{\prime }$ for (V,E,T,u) in the following way. For every page q and every pair of consecutive requests j₁,j₂ of page q, we add i(j₁,j₂) to $T^{\prime }$ if and only if page q is evicted from (and therefore re-loaded into) the cache between $t_{j_{1}}$ and $t_{j_{2}}$. We also add $i^{*}_{q}$ to $T^{\prime }$ for all $q\in \mathcal {P}$. It is clear that $|T^{\prime }|$ is exactly the number of times a page is brought into the cache in the original solution. We now check that $T^{\prime }$ is a feasible solution. Consider an edge e(t) ∈ E. Then $p(T_{e(t)}\setminus T^{\prime })$ is the sum of sizes of the pages that are in the cache at time t that are not requested exactly at time t. The total size of all pages in the cache is at most M, so $p(T_{e(t)}\setminus T^{\prime })+ {\sum }_{j\in R: t_{j}=t} s(q_{j})\leq M$. Then, as $p(T_{e(t)}) = p(T_{e(t)}\cap T^{\prime }) + p(T_{e(t)}\setminus T^{\prime })$ and $u_{e(t)} = p(T_{e(t)}) - M + {\sum }_{j\in R: t_{j}=t} s(q_{j})$ we conclude that $p(T^{\prime }\cap T_{e(t)})\geq u_{e(t)}$. Also it holds by construction that $p(T^{\prime }\cap T_{e_{0}})=u_{e_{0}}$.

Let now $T^{\prime }$ be a feasible solution to (V,E,T,u). Of course $i^{*}_{q}\in T^{\prime }$ for all $q\in \mathcal {P}$. This accounts for the first time each page is brought into the cache. We construct a solution $S^{\prime }$ to $(\mathcal {P},\mathcal {R},M)$ as follows. For every page q and every pair of consecutive requests j₁,j₂ of page q we keep page q in the cache between $t_{j_{1}}$ and $t_{j_{2}}$ if and only if $i(j_{1},j_{2})\not \in T^{\prime }$. Thus, for each element in $T^{\prime }$ we have to bring a page into the cache once, and then the cost of the solution is exactly $|T^{\prime }|$. We have to check that the size of the pages in the cache never exceeds M in $S^{\prime }$. In fact, note that the total size of the pages in the cache at time t is $p(T_{e(t)}\setminus T^{\prime }) +{\sum }_{j\in R: t_{j}=t} s(q_{j})$. But $p(T_{e(t)}\cap T^{\prime })\geq u_{e(t)}$, and therefore,

$$ \begin{array}{@{}rcl@{}} p(T_{e(t)}\cap T^{\prime}) &\geq& p(T_{e(t)}) - M + \sum\limits_{j\in R: t_{j}=t} s(q_{j}) \\ \Leftrightarrow\qquad \qquad \qquad M &\geq & p(T_{e(t)}) +p(T_{e(t)}\cap T^{\prime})+ \sum\limits_{j\in R: t_{j}=t} s(q_{j})\\ \Leftrightarrow\qquad\qquad\qquad M &\geq& p(T_{e(t)}\setminus T^{\prime}) +\sum\limits_{j\in R: t_{j}=t} s(q_{j}) . \end{array} $$

□