Weighted Online Problems with Advice

Abstract

Recently, the first online complexity class, A O C, was introduced. The class consists of many online problems where each request must be either accepted or rejected, and the aim is to either minimize or maximize the number of accepted requests, while maintaining a feasible solution. All A O C-complete problems (including Independent Set, Vertex Cover, Dominating Set, and Set Cover) have essentially the same advice complexity. In this paper, we study weighted versions of problems in A O C, i.e., each request comes with a weight and the aim is to either minimize or maximize the total weight of the accepted requests. In contrast to the unweighted versions, we show that there is a significant difference in the advice complexity of complete minimization and maximization problems. We also show that our algorithmic techniques for dealing with weighted requests can be extended to work for non-complete A O C problems such as Matching in the edge arrival model (giving better results than what follow from the general A O C results) and even non- A O C problems such as scheduling.

Appendices

Appendix A: AOC-Complete Problems

For completeness, we state the full definition of minASGk from [7]:

Definition 7 ([7])

The minimum asymmetric string guessing problem with known history, minASGk, has input 〈?, x ₁,…, x _n 〉, where x = x ₁…x _n ∈{0, 1}ⁿ, forsome $n\in \mathbb {N}$.For 1 ≤ i ≤ n,round i proceeds as follows:

• 1. If i > 1,the algorithm learns the correct answer, x _i−1,to the request in the previous round.

• 2. The algorithm answers y _i = f(x ₁,…, x _i−1) ∈{0, 1},where f is a function defined by the algorithm.

The output y = y ₁…y _n computed by thealgorithm is feasible, if $x\sqsubseteq y$.Otherwise, y is infeasible. The cost of a feasible output is |y|₁, and the cost of aninfeasible output is ∞.

In addition to minASGk, the class of A O C-complete problems also contains many graph problems. The following four graph problems are studied in the vertex-arrival model, so the requests are vertices, each presented together with its edges to previous vertices. The first three problems are minimization problems and the last one is a maximization problem. In Vertex Cover, an algorithm must accept a set of vertices which constitute a vertex cover, so for every edge in the requested graph, at least one of its endpoints is accepted. For Dominating Set, the accepted vertices must constitute a dominating set, so every vertex in the requested graph must be accepted, or one its neighbors must be accepted. In Cycle Finding, an algorithm must accept a set of vertices inducing a cyclic graph. For Independent Set, the accepted vertices must form an independent set, i.e., no two accepted vertices share an edge.

For Disjoint Path Allocation a path P is given, and the requests are subpaths of P. The aim is to accept as many edge disjoint paths as possible.

For Set Cover, the requests are finite subsets from a known universe, and the union of the accepted subsets must be the entire universe. The aim is to accept as few subsets as possible.

Appendix B: Reductions for Theorem 2

In the proof of Theorem 2, a reduction sketch was given for the weighted online version of Vertex Cover. Here we include sketches for the reductions for the weighted versions of Cycle Finding, Dominating Set and Set Cover.

1.1 Cycle Finding

Each input σ = 〈x ₁, x ₂,…, x _n 〉 to the problem minASGk, is transformed to f(σ) = 〈v ₁, v ₂,…, v _n 〉, where V = {v ₁, v ₂,…, v _n } is the vertex set of a graph with edge set E = {(v _j , v _i ): f ^′(x _i ) = j}∪{(v _min, v _max)}, where f ^′(x _i ) is the largest j < i such that x _j = 1, max is the largest i such that x _i = 1, and min is the smallest i such that x _i = 1. If |σ|₁ > 2, the vertices corresponding to 1s form the only cycle in the graph.

The advice used by the minASGk algorithm Alg₁ consists of the advice used by the Cycle Finding algorithm Alg₂ in combination with 1 bit indicating whether or not |σ|₁ ≤ 2 and in this case (an encoding of) one or two indices of 1s in the input sequence. If |σ|₁ > 2, then Alg₂ accepts some vertices, and Alg₁ returns a 1 for the x _i corresponding to each of those vertices.

If Alg₁ returns a non-optimal feasible set, Alg₂ does too, and the sets have the same weights, so Alg₁(σ) ≤Alg₂(f(σ)) + Opt(σ). In this case, the weights of the optimal solutions for σ and f(σ) are both the sum of the weights of the elements corresponding to 1s in σ, so f is a length preserving O(f(n))-reduction.

1.2 Dominating Set

Each input σ = 〈x ₁, x ₂,…, x _n 〉 to the problem minASGk, is transformed to f(σ) = 〈v ₁, v ₂,…, v _n 〉, where V = {v ₁, v ₂,…, v _n } is the vertex set of a graph with edge set E = {(v _i , v _max)}., where max is the largest i such that x _i = 1.

The advice used by the minASGk algorithm Alg₁ consists of the advice used by the Dominating Set algorithm Alg₂ in combination with 1 bit indicating whether or not |σ|₁ = 0. If |σ|₁ ≥ 1, then there is another bit of advice indicating whether or not Alg₂ accepted v _max. If Alg₂ did not accept v _max, the advice also contains an index of a vertex corresponding to a 0 in σ which was accepted, plus the index of v _max.

If Alg₁’s solution is feasible, but not optimal, then |σ|₁ > 0 and Alg₂ accepts some vertices, and Alg₁ returns a 1 for the x _i corresponding to each of those vertices (though, in the case where v _max was rejected, it answers 1 for x _max and answers 0 for the earlier request indicated by the advice).

If |σ|₁ > 0 a minimum weight dominating set for f(σ) consists of exactly those vertices corresponding to 1s in σ, so the weights of the optimal solutions for σ and f(σ) are both the sum of the weights of the elements corresponding to 1s in σ, unless Alg₂ did not accept v _max. However, the weight of x _max ≤Opt(σ), so Alg₁(σ) ≤Alg₂(f(σ)) + Opt(σ). Thus, f is a length preserving O(log(n)-reduction.

1.3 Set Cover

This reduction is very similar to that for Dominating Set. Each input σ = 〈x ₁, x ₂,…, x _n 〉 to the problem minASGk, max is the largest i such that x _i = 1. In the set cover instance, the universe is {1,…, n}, and f(σ) is a set of n requests, where request i is {i}, unless i = max, in which case, the set consists of max and all of the j where x _j = 0.

As with the reduction to Dominating Set, this is a length preserving O(log(n)-reduction.