The Ad Types Problem

TL;DR

This paper introduces efficient algorithms for the Ad Types Problem, optimizing ad-slot matching with discount curves and providing solutions for both with and without gap rules, including complexity analysis and pricing strategies.

Contribution

It presents a novel algorithm for maximum weight matching in the Ad Types Problem with improved runtime and a method for VCG pricing, also addressing the problem with gap rules.

Findings

Algorithm runs in O(n^2(k + log n)) for maximum weight matching.

VCG pricing can be computed in asymptotic same time complexity.

The problem with gap rules is hard to approximate, but an exact dynamic programming solution exists.

Abstract

The Ad Types Problem (without gap rules) is a special case of the assignment problem in which there are $k$ types of nodes on one side (the ads), and an ordered set of nodes on the other side (the slots). The edge weight of an ad $i$ of type $\theta$ to slot $j$ is $v_i\cdot \alpha^{\theta}_j$ where $v_i$ is an advertiser-specific value and each ad type $\theta$ has a discount curve $\alpha^{(\theta)}_{1} \ge \alpha^{(\theta)}_{2} \ge ... \ge 0$ over the slots that is common for ads of type $\theta$. We present two contributions for this problem: 1) we give an algorithm that finds the maximum weight matching that runs in $O(n^2(k + \log n))$ time for $n$ slots and $n$ ads of each type---cf. $O(kn^3)$ when using the Hungarian algorithm---, and 2) we show to do VCG pricing in asymptotically the same time, namely $O(n^2(k + \log n))$, and apply reserve prices in $O(n^3(k + \log n))$. The Ad Types Problem (with gap rules) includes a matrix $G$ such that after we show an ad of type $\theta_i$, the next $G_{ij}$ slots cannot show an ad of type $\theta_j$. We show that the problem is hard to approximate within $k^{1- \epsilon}$ for any $\epsilon > 0$ (even without discount curves) by reduction from Maximum Independent Set. On the positive side, we show a Dynamic Program formulation that solves the problem (including discount curves) optimally and runs in $O(k\cdot n^{2k + 1})$ time.

Equations

$$\begin{array}[]{cr@{\hspace{3pt}}l@{\hspace{2em}}{l}}\vspace{\sepobjective}\mathrm{maximize}&\sum_{(i,j)\in E}\hskip 3.0&v_{ij}x_{ij}\hfil\hskip 20.00003pt\\ \mathrm{subject\ to}&\sum_{j}x_{ij}\hskip 3.0&\leq 1\hfil\hskip 20.00003pt&\forall i\in U\\ &\sum_{i}x_{ij}\hskip 3.0&\leq 1\hfil\hskip 20.00003pt&\forall j\in V\\ &x_{ij}\hskip 3.0&\geq 0\hfil\hskip 20.00003pt&\forall(i,j)\in E\end{array}$$

$$\begin{array}[]{cr@{\hspace{3pt}}l@{\hspace{2em}}{l}}\vspace{\sepobjective}\mathrm{minimize}&\sum_{i\in U}u_{i}\hskip 3.0&+\sum_{j\in V}p_{j}\hfil\hskip 20.00003pt\\ \mathrm{subject\ to}&u_{i}+p_{j}\hskip 3.0&\geq v_{ij}\hfil\hskip 20.00003pt&\forall(i,j)\in E\\ &u_{i}\hskip 3.0&\geq 0\hfil\hskip 20.00003pt&\forall i\in U\\ &p_{j}\hskip 3.0&\geq 0\hfil\hskip 20.00003pt&\forall j\in V\end{array}$$

$${\alpha }_{j^{\prime }}^{(\theta )}\cdot v_i$$

$${\alpha }_j^{(\theta )}\cdot v_{i^{\prime }}$$

$${\alpha }_j^{(\theta )}\cdot v_i$$

$${\alpha }_{j^{\prime }}^{(\theta )}\cdot v_{i^{\prime }}$$

$${\alpha }_{j^{\prime }}^{(\theta )}\cdot v_i+{\alpha }_j^{(\theta )}\cdot v_{i^{\prime }}$$

$$\ge {\alpha }_j^{(\theta )}\cdot v_i+{\alpha }_{j^{\prime }}^{(\theta )}\cdot v_{i^{\prime }}.$$

$$u_i(b_{-i},b_i)$$

$$=\{\begin{array}{ll}S{W}_i(B^{\prime })-\left(S{W}_{-i}(b_i\to r_i,B_{-i}^{\prime })-S{W}_{-i}(B^{\prime })+S{W}_i(b_i\to r_i,B_{-i}^{\prime })\right)& \text{if }{b}_i\ge r_i\\ 0& \text{otherwise}\end{array}$$

$$=\{\begin{array}{ll}SW(B^{\prime })-SW(b_i\to r_i,B_{-i}^{\prime })& \text{if }{b}_i\ge r_i\\ 0& \text{otherwise}\end{array}$$

$$\displaystyle T[\bm{n^{\theta}},\bm{s^{\theta}}]=\max_{j\in P(\theta_{l},\bm{n^{\theta}},\bm{s^{\theta}})}\Big{\{}T[\bm{n^{\theta}_{-l,n^{\theta}_{l}-1}},\bm{s^{\theta}}_{-l,j}]+v_{n^{\theta_{l}}}^{\theta_{l}}\cdot\alpha_{s^{\theta_{l}}}^{\theta_{l}}\Big{\}}\text{, where }\theta_{l}=\max_{\theta_{l}}s^{\theta_{l}}$$

Full text

The Ad Types Problem (with gap rules) includes a matrix $G$ such that after we show an ad of type $\theta_{i}$, the next $G_{ij}$ slots cannot show an ad of type $\theta_{j}$. We show that the problem is hard to approximate within $k^{1-\epsilon}$ for any $\epsilon>0$ (even without discount curves) by reduction from Maximum Independent Set. On the positive side, we show a Dynamic Program formulation that solves the problem (including discount curves) optimally and runs in $O(k\cdot n^{2k+1})$ time.

1 Introduction

In online advertising, there is a hugely influential literature on sponsored search [41, 11, 29]. In this setting, a small number of ads (typically 2 or 3) are shown next to organic search results using a position auction [41, 11]. Since users tend to look at the results from top to bottom, an ad will have a higher click-through-rate (CTR) in a higher slot, and are therefore higher slots rae considered more valuable. The common way to capture this slot effect is with a separable model, where ad slots have an associated discount $1\geq\alpha_{1}\geq..\geq 0$ that represents the advertiser-agnostic CTR of the slot. The auction is run taking the expected number of clicks (as represented by $\alpha_{j}$) as the “quantity of good” that is sold. Work in this area has proliferated and the position auction model lies at the basis of many applications of online advertising, even outside of sponsored search.

While the position auction model has been very influential in online advertising, there are important differences between the multi-slot ad allocation problem on a search results page and the multi-slot problem in content feeds like Facebook’s News Feed, reddit, and Apple News. In content feeds, ads are interspersed with organic content, so not all ads are visible from the start, and when the first ad is shown it is not clear how many ads will have to be allocated.111While this may not be a problem when deciding which ad to show the user, pricing generally needs information about how many items are sold, and what the other competition is in the auction. Moreover, there are many different types of organic content like text, photos, and videos mixed in the same stream. Similarly, there are many different types of ads that have different associated objectives: some ads simply want the user to see them, others want the user to click or view a video. These objectives must be considered when allocating slots to ads, since the probability that a user will see an impression-ad is quite different from the probability that she’ll watch a video ad or click on a link-click ad. There may be diversity rules as well that after a video ad you cannot show another video ad, but it’s okay to show a banner ad. These considerations have implications on which ads are eligible to be shown in which slots.

The standard position auction model fails to capture these important differences. For example, the probability of a user watching a video ad typically decays differently than a link-click ad. If one were to use the same discount curve for ads of different types, this could lead to a suboptimal allocation:

Example 1.1**.**

Suppose we have a setting with 2 ad types, link-click ads and video ads, two ad slots, and we have discount curve $\alpha_{1}=\tfrac{1}{2},\alpha_{2}=\tfrac{1}{4}$. These discounts are accurate for link-click ads (i.e. $\alpha^{(\text{link})}_{1}=\tfrac{1}{2},\alpha^{(\text{link})}_{2}=\tfrac{1}{4}$), but for video ads, the user is more likely to watch the video in the second slot than they are to click a link in that slot: $\alpha^{(\text{video})}_{1}=\frac{1}{2}$, $\alpha^{(\text{video})}_{2}=\frac{1}{3}$.

Consider a video ad with bid \12$and a link-click ad with bid$$10$. The optimal allocation assuming that discount curve$\alpha$is accurate for both ads would assign the video ad to slot 1 and the link-click ad to slot 2 for total value$\tfrac{1}{2}\cdot$12+\tfrac{1}{4}\cdot$10=$8.50$. However, switching the ads yields total value$\tfrac{1}{2}\cdot$10+\tfrac{1}{3}\cdot$12=$9>$8.50$.222Those familiar with auction theory will note that this also implies that VCG prices w.r.t.$\alpha$ would not be incentive compatible. For readers less familiar with auction theory, we provide a primer in Section 2.1.

In this paper we propose a new theoretical model for online advertising that addresses these issues. It captures the position auction as a special case, but can handle discount curves for multiple types and intersperse advertising with organic content in a dynamic manner.333While our motivation for studying this problem comes from online advertising in content streams, it captures many other interesting settings that are unrelated to online advertising. For example, the setting without gap rules can model a worker with different time slots and jobs of different types that need to be done; jobs are most valuable when completed early and delays for jobs of the same type are discounted similarly. Adding gap rules can model the cost of moving between locations (in the physical world) or context-switching (in the digital world). An Ad Types Problem instance has $k$ ad types, that each have their own discount curve over $n$ slots, i.e. for each ad type $\theta$ we have a discount curve $\alpha^{(\theta)}_{1}\geq\alpha^{(\theta)}_{2}\geq\ldots\geq\alpha^{(\theta)}_{n}\geq 0$ that represents the slot-specific action-rate for ads of type $\theta$. All ad types agree on the order of the slots. Gap rules are modeled by a $k\times k$ matrix $G$, which indicates for each pair of ad types $(\theta_{i},\theta_{j})$, that after showing an ad of type $\theta_{i}$, the next $G_{ij}$ stories cannot be of type $\theta_{j}$.

We first focus on the special case where $G=\bf 0$, i.e. different ad types have different discount curves but there are no constraints on the gaps between ads. In this setting, the Ad Types Problem is a special case of the maximum-weight bipartite matching problem (also known as the assignment problem), so we could find an optimal allocation using the Hungarian algorithm in $O(kn^{3})$ time [37] (where $k$ is the number of ads, $n$ the number of slots, and we have $n$ ads per type). Our first result is an algorithm that finds the optimal allocation in $O(n^{2}(k+\log n))$ time, saving a linear factor. In auctions, it’s not only important to find the optimal allocation of ads to slots, one also needs to compute appropriate prices. We show that we can compute VCG prices in asymptotically the same time as finding the optimal allocation, i.e. $O(n^{2}(k+\log n))$. A common way to control revenue is to set an appropriate minimum bid (also knows as a reserve price [34]); we show that we can compute incentive-compatible prices with advertiser-specific reserve prices for all ads in $O(n^{3}(k+\log n))$ time.

Next we consider the more general Ad Types problem with both discount curves and gap rules (where $G\neq\bf 0$). We show that the problem is hard to approximate within $k^{1-\epsilon}$ for any $\epsilon>0$ (even without discount curves) by reduction from Maximum Independent Set. On the positive side, we show a Dynamic Program formulation that solves the problem (including discount curves) optimally and runs in $O(k\cdot n^{2k+1})$ time.

1.1 Related Work

Assignment Problem.

The maximum-weight bipartite matching problem, also known as the assignment problem, is a classical problem in operations research. Let $(A,B,E)$ be a complete bipartite graph with edges weights $v:E\rightarrow\mathbb{R}^{+}$, and $V=A\cup B$ the set of nodes; the goal is to find a matching $M$ of maximal total weight $\sum_{e\in M}v(e)$. Kuhn [28] proposed an algorithm for this problem—which he called the Hungarian algorithm—based on ideas by Kőnig and Egerváry, though he only proved that the algorithm would terminate, not what the time complexity is. Munkres [32] showed that the time complexity of the Hungarian algorithm is $O(|V|^{4})$. Edmonds and Karp [12] gave a $O(|V|^{3})$ time algorithm for balanced graphs, and Ramshaw and Tarjan [37] more recently gave an algorithm for unbalanced graphs (wlog assume $|A|<|B|$) that runs in $O(|E||A|+|A|^{2}\log|A|)$. Since the seminal work on the assignment problem, there has been active research into relevant special cases. In particular there is a line of work on convex bipartite graphs, where the right side of the graph is ordered, and nodes on the left can only be connected to a single contiguous block of nodes on the right. For the unweighted case, a line of work starting with Glover [19, 30, 15] shows that the problem can be solved in time linear in the number of nodes $O(|V|)$. General weights are not considered, though early work on vertex-weighted bipartite graphs (where each node $i$ has an associated weight $w_{i}$ and the weight of an edge from $i$ to $j$ is $w_{ij}=w_{i}+w_{j}$) yield a $O(|E|+|B|\log|A|)$ time algorithm [25]. More recently, Plaxton [35, 36] showed that Two-Directional Orthogonal Ray Graphs (a generalization of convex graphs) admit a $O(|V|\log|V|)$ time algorithm.

Sharathkumar and Agarwal [40] consider a more general set of edge weights, where nodes are embedding in $d$-dimensional space, and the weights of the complete bipartite graph are all either the $L_{1}$ or $L_{\infty}$ metric. They present an algorithm to solve the maximum weight bipartite in $O(|V|^{3/2}\log^{d+O(1)}(|V|)\log\Delta)$, where $\Delta$ is the diameter of the space that contains the points.

None of the results on specializations cover The Ad Types Problem setting (even without gap rules).

Ad Auctions.

The simple separable model for position auctions appears in Varian [41] and Edelman et al. [11]. One body of related work relaxes the assumption that action rates are separable. One common theme is to model externalities between ads (also related to our gap rules) [26, 16, 18, 3, 2, 20, 17]. Of note, [26, 16, 13, 2] study algorithms for computing allocations in models where the user’s attention cascades and prove hardness results. A different generalization is to allow arbitrary action rates that are still independent between ads [1, 6, 5], which corresponds to the Ad Type Problem (without gap rules) where each ad has a unique type.

Another generalization of the basic position auction allows ads to be placed in complex ways. A few papers study mechanisms that permit presentation constraints and/or ads with variable presentation [23, 4, 22, 33, 8]. Mahdian et al. study auctions for ads displayed on maps along with organic results [31] (since places of interest are connected to a physical location, this imposes constraints on where ads can be placed).

Finally, the connections between ad auctions and max-weight matching (and the Hungarian algorithm) have been studied before as well [9, 5, 27, 10].

1.2 Contributions

This paper presents three main contributions:

• •

Optimal Allocation. Firstly, we give an algorithm to optimally solve the Ad Types problem without gap rules. This setting is a special case of the assignment problem with applications beyond ad auctions. Our algorithm is a specialization of the Hungarian algorithm to find the maximum-weight matching in the bipartite graph that uses the structure of the Ad Types Problem to run in $O(n^{2}(k+\log n))$ time (compared to $O(kn^{3})$ for running the Hungarian algorithm on the instance; Theorem 3.1). While we are motivated by ad auctions, this setting also models other common settings like a worker who needs to do several tasks of different types.

• •

Pricing. Secondly, we show that we can do incentive-compatible pricing in this setting with minimal overhead. First we show how to compute VCG prices efficiently. Naively, VCG prices are computed by resolving the original problem $n$ times (removing 1 buyer in each instance). We show that we can extract VCG prices from the dual variables in our algorithm when they are properly updated. This yields VCG prices in $O(n^{2}(k+\log n))$ time (cf. $O(n^{3}(k+\log n)$ when implemented naively; Theorem 3.6). Second, we show that we can apply reserve prices (and in fact in all single-parameter environments) without a changepoint algorithm [34, 38]. For our case, this yields a $O(n^{3}(k+\log n))$ time algorithm (Corollary 3.9).

• •

Gap Rules. Finally, we consider the more general Ad Types problem with both discount curves and gap rules (where $G\neq\bf 0$). We show that the problem is hard to approximate within $k^{1-\epsilon}$ for any $\epsilon>0$ (even without discount curves) by reduction from Maximum Independent Set (Theorem 4.1). On the positive side, we give a Dynamic Program formulation that solves the problem (including discount curves) optimally and runs in $O(k\cdot n^{2k+1})$ time (Theorem 4.2).

2 Preliminaries

In this section we give a primer on auction theory, a formal definition of the ad types problem, and a review of the Hungarian Algorithm and its application to Ad Types problem.

2.1 Auction Theory

There are $n$ (strategic) agents, and some finite set of outcomes $\Omega$. Agents have some value function over outcomes: $v_{i}:\Omega\rightarrow\mathbb{R}$. An auction $\mathcal{A}=(\mathcal{X},\mathcal{P})$ consists of an allocation function $\mathcal{X}:(\Omega\rightarrow\mathbb{R})^{n}\rightarrow\Omega$ that takes the bids (meaning a report of the valuation) of $n$ agents and selects the outcome, and a payment function $\mathcal{P}:(\Omega\rightarrow\mathbb{R})^{n}\rightarrow\mathbb{R}$.

A common goal444Other common goals include revenue and a notion of high-value allocation with fairness concerns. for the auctioneer is to select the outcome $\omega^{*}$ with the maximal total value, which is known as the social welfare: $\omega^{*}=\operatorname*{arg\,max}_{\omega\in\Omega}\sum_{i=1}^{n}v_{i}(\omega)$. Note however, that the auctioneer doesn’t have direct access to the valuation function $v_{i}$; she elicits them as bids $b_{i}$. Each agent cares about their own utility, $u_{i}(b_{i},b_{-i})=v_{i}(\mathcal{X}(b_{i},b_{-i}))-\mathcal{P}(b_{i},b_{-i})$, where $b_{-i}$ are the bids of all agents except $i$. Thus, given bids by the other agents $b_{i}$ she will report $b^{*}_{i}=\operatorname*{arg\,max}_{b_{i}}u_{i}(b_{i},b_{-i})$. The auctioneer can use the pricing function to incentivize agents to report their true valuations. An auction is called dominant strategy incentive compatible (DSIC), or simply incentive compatible, if for any bid profile $b_{-i}$ of agents other than $i$, agent $i$ always maximizes their utility by bidding truthfully: $v_{i}\in\operatorname*{arg\,max}_{b_{i}}u_{i}(b_{i},b_{i-1}))$. Celebrated work by Vickrey, Clarke and Groves [42, 7, 21] shows that it is always possible to do this by charging agents their externality.

A particularly interesting class of valuation functions are single-parameter in the following sense: there is some function $x_{i}:\Omega\rightarrow\mathbb{R}^{+}$ that maps outcomes to a “quantity of goods” that agent $i$ receives. The valuation function is then expressed as $v_{i}(\omega)=v_{i}\cdot x_{i}(\omega)$, where we overload $v_{i}$ to be a single “value-per-unit-good” parameter. Single-parameter settings are quite common, e.g. single-item auction are single parameter: an agent has a value $v_{i}$ for receiving the good, the outcome space consists of the item going to each of the agents that participate, and $x_{i}(\omega)=1$ iff agent $i$ receives the good in outcome $\omega$ and it is 0 otherwise. For single-parameter environments the allocation function $\mathcal{X}$ and pricing function $\mathcal{P}$ take as input a single number for each advertiser: their per-unit bid $b_{i}\in\mathbb{R}$.

Besides social welfare, a common goal for an auctioneer is to maximize revenue. Myerson [34] shows how to maximize expected revenue in single-parameter environments when a buyer has knowledge about the distributions $F_{1},F_{2},...,F_{n}$ from which each buyer draws their value. For a buyer $i$ whose distribution $F_{i}$ is regular—meaning $\phi_{i}(v):=v-\frac{1-F_{i}(v)}{f_{i}(v)}$ with CDF $F_{i}$ and corresponding PDF $f_{i}$ is monotonically non-decreasing—the optimal expected revenue from that buyer is obtained by setting reserve price $r_{i}$ (also known as a minimum bid) equal to $\phi^{-1}(0)$.555Myerson also extends the results to non-regular distributions, though that is outside the scope of the present work. Setting the optimal reserve price for a non-regular distribution is still guaranteed to be within a factor 2 of optimal, see e.g. [39]. To apply a reserve price $r_{i}$, let $x_{i}(b_{i};b_{-i})$ be the quantity of goods that a single-parameter buyer receives. If $b_{i}<r_{i}$ the buyer is rejected from the auction and thus receives nothing; otherwise $x_{i}$ is identical to the setting without reserve price $r_{i}$. The incentive-compatible price corresponding to $x_{i}$ is given by Myerson’s payment identity: $p_{i}=\int_{b=0}^{b_{i}}b\cdot x^{\prime}_{i}(b;b_{-i})\text{ d}b$. For discrete $x_{i}$, this becomes a summation over the changepoints where the allocation changes.

2.2 The Ad Types Problem

The Ad Types Problem involves computing an allocation of a set of $N$ ads to $n\leq N$ slots. Ads come in one of $k$ different ad types $\theta_{l}$, for $l\in\{1,...,k\}$. We let the ads of type $\theta_{l}$ be $a^{(\theta_{l})}_{i}$ for $i\in{1,\ldots,n_{l}}$. There are three main components to the definition of the problem:

• •

Valuations. Ad $i$ of type $\theta$ has a value-per-conversion (a.k.a. value-per-action) $v^{(\theta)}_{i}$. Ads of different types have different conversion events, e.g. for a display ad the conversion event is a view, for a link ad the conversion event is a link click, and for a video ad the conversion event is the user watching video ad. For each ad type $\theta$, we index the ads in non-increasing order of valuation, i.e. $v^{(\theta)}_{1}\geq v^{(\theta)}_{2}\geq\ldots\geq v^{(\theta)}_{n_{l}}\geq 0$.

• •

Discount curves. We assume a separable model for discount curves where we can write $\Pr[\text{conversion on ad }i\text{ (of type }\theta\text{) in slot }j]=\alpha^{\theta}_{j}\cdot\beta_{i}$ where $\alpha^{\theta}_{j}$ is the slot effect for a particular ad type $\theta$ (e.g., the probability that a user will watch a video ad if its shown in the $j$th slot) and $\beta_{i}$ is the advertiser quality (this separable model is also standard in position auctions [41, 11]). In the remainder of the paper we assume wlog that the advertiser effect has already been included in the advertiser’s value, i.e., if the value-per-conversion of the advertiser is $v_{i}^{\prime}$, then $v_{i}=\beta_{i}\cdot v^{\prime}_{i}$. We further abuse notation to let $v_{ij}=\alpha^{\theta}_{j}\cdot v_{i}$ for ad $i$ of type $\theta$ in slot $j$.

Discounts are monotonically non-increasing, and all ad types agree on the order of slots, i.e. for each ad type $\theta$, we have $\alpha^{(\theta)}_{1}\geq\alpha^{(\theta)}_{2}\geq\ldots\geq\alpha^{(\theta)}_{n}\geq 0$.

• •

Gap rules. When ads are interspersed with organic content, there must be some way to control how many ads are shown. In the simplest case, where there’s only one type of ad, this can be implemented by a gap rule $g$, which states that two ads must be at least $g$ slots apart from each other. When there are multiple ad types, there is a $k\times k$ matrix $G$, which indicates for each pair of ad types $(\theta_{i},\theta_{j})$, that after showing an ad of type $\theta_{i}$, the next $G_{ij}$ stories cannot be of type $\theta_{j}$.

The Ad Types Problem is to find a social welfare maximizing allocation that obeys the gap rules.

2.3 The Hungarian Algorithm

The Hungarian Algorithm [28, 32] is a classical algorithm for computing a maximum weight matching in a bipartite graph. Starting from a trivial primal solution (empty matching) and a trivial dual solution, the algorithm iteratively increases the cardinality of the matching while improving the value of the dual solution until the value of the primal solution equals that of the dual.

Let $(U,V,E)$ be a complete bipartite graph with edges weights $v:E\rightarrow\mathbb{R}^{+}$. The primal/dual pair of linear programs capturing the problem are as follows.

[TABLE]

[TABLE]

The algorithm starts from an empty primal solution $M=\emptyset$, and a trivial feasible dual solution $u_{i}=0$ for all $i\in U$ and $p_{j}=\max_{(i,j)\in E}v_{ij}$ for all $j\in V$. In each iteration, the algorithm identifies the set of tight edges $T=\{(i,j)\in E:u_{i}+p_{j}=v_{ij}\}$ and builds an alternating BFS tree $B$ (also known as Hungarian tree) in $(U,V,T)$ out of the free vertices in $V$. If the alternating tree contains an augmenting path $A$, we augment $M$ with $A$ thus increasing its cardinality; if no such path is available, we can update the dual solution by reducing the dual value of $V\cap B$ and increasing the dual value of $U\cap B$ by the same amount until a new edge become tight. This update maintains feasibility while reducing the value of the dual solution and makes at least one new edge tight, which in turn allows us to grow the alternating tree further.

Throughout the execution of the algorithm we maintain the invariants that the dual solution is feasible and that the edges in the matching $M$ are tight. As a result, at the end of the algorithm we have a matching whose weight equals the value of the dual feasible solution, which acts as a certificate of its optimality.

Using the right data structures, it is possible to implement the algorithm so that the amount of work done between each update to $M$ is $O(|E|+|U|\log|U|)$. Therefore, if we let $M^{*}$ be a maximum weight matching, then the Hungarian algorithm can be implemented to run in $O(|M^{*}|(|E|+|U|\log|U|))$ time [14].

3 Ad Types Problem without Gap Rules

In this section we consider the ad types problem with discount curves but no gap rules. In this model we have $k$ ad types, and each ad type has its own monotonically decreasing discount curve $\alpha_{j}^{(\theta_{l})}$ for $l\in 1,2,\ldots,k$. Without gap rules, the problem becomes a simple maximum weight bipartite assignment on a complete graph with $N$ vertices (ads) on one side of the bipartition and $n$ vertices (slots) on the other side of the bipartition, with $n<N$. Therefore, the Hungarian algorithm can solve this problem in $O(Nn^{2})$ time. We will assume throughout there are exactly $n$ ads of each type666If an ad type has fewer than $n$ ads, we can append ads with value [math], if there are more than $n$ ads of a type, with loss of generality we can restrict attention to the $n$ highest-value ads., hence the Hungarian algorithm runs in $O(kn^{3})$ time.

In this section we start by giving an algorithm that finds the maximum-weight bipartite matching in $O(n^{2}(k+\log n))$ time (Section 3.1). We show that in some sense the dependency on $k$ can be expected: when $k=n$, the problem is no easier than solving the assignment problem (i.e. a common order of the slots does not improve the running time; see Section 3.2). We then turn our attention to pricing and show that computing VCG prices can be done in $O(n^{2}(k+\log n))$ (Section 3.3 and that we can apply reserve prices in $O(n^{3}(k+\log n))$ (Section 3.4).

3.1 Finding the Optimal Allocation

We present an adaptation of the Hungarian algorithm [28, 32] that exploits the special structure of the Ad Types problem. In the following we use the language of markets to describe the Hungarian algorithm: the dual variable of a slot $j$ corresponds to a price $p_{j}$, while a dual variable of an advertiser $i$ corresponds to the utility $u_{i}$ of the advertiser if they get an item out their demand set (given the prices) [10]. Moreover, the instance is a complete bipartite graph with ads on one side and slots on the other side where the weight of the edge $(i,j)$ is $v_{ij}$. The maximum-weight matching in the bipartite graph corresponds to the social-welfare maximizing allocation of ads to slots. For ease of exposition, we assume that values and discounts are monotonically strictly decreasing, this restriction can be lifted by consistent tie-breaking.

Algorithm 1 shows how to compute the optimal allocation in an Ad Types instance. The algorithm is identical to how the Hungarian algorithm is commonly implemented; the only difference is how we maintain the set of possible new edges in Lines 6 and 13. The algorithm initializes the dual solution $(u,p)$ to be feasible, and starts with an empty matching $M$. Algorithm considers slots in descending order in each iteration of the for loop in Line 3; we call each such iteration a phase.

During each phase we iteratively update the dual variables until we find an augmenting path to increase the size of the matching $M$ by one. In each of these iterations within a phase we explore a tight edge leading to a matched edge and both edges are added to our alternating tree. Every time we add a new matched slot $j^{\prime}$ to the alternating tree we explore the edges incident on $j^{\prime}$ using the routine UpdatePossibleNewEdges, which scan the edges incident on $j^{\prime}$ and works out which edges are tight and when the remaining edges will become tight. All these new edges are stored in a priority queue for later retrieval.

High-level running time analysis.

Even though the algorithm is not well defined yet (we have not specified how to implement UpdatePossibleNewEdges), still we can say something about the running time of the algorithm.

Each phase is implemented using a priority queue $P$ over some of the ads not in $B$. For each ad $i^{\prime}$ in $P$ we keep track of the next edge $(i^{\prime},j^{\prime})$ that would become tight given the current structure of $B$. The priority of $i^{\prime}$ captures when this next edge becomes tight, the smaller the priority the sooner it becomes tight; similarly, if $i^{\prime}$ already has a tight edge incident on itself then it should have the smallest priority in the queue.

In the normal implementation of the Hungarian Algorithm, the procedure UpdatePossibleNewEdges$(P,v,\alpha,j^{\prime})$ iterates over all edges $(i^{\prime},j^{\prime})$ incident on $j^{\prime}$. If $i^{\prime}\in B$ we can ignore the edge as $i^{\prime}$ has already been discovered and its slack $v_{i^{\prime},j^{\prime}}-\alpha_{j^{\prime}}-u_{i^{\prime}}$ will not change with future updates (since now both $i^{\prime}$ and $j^{\prime}$ belong to $B$). If $i^{\prime}\notin B$ then we compute its current slack $v_{i^{\prime},j^{\prime}}-\alpha_{j^{\prime}}-u_{i^{\prime}}$ to work out when it will become tight and compare this against the time of the current next tight edge incident on $i^{\prime}$, which we may need to update.

Without making any assumptions on the structure of the valuations, in the worst case in each iteration of the while loop in Line 7 we perform $O(nk+\log nk)=O(nk)$ work (assuming a Fibonacci heap implementation for $P$) since there are $kn$ ads in total and $kn$ edges incident on $j^{\prime}$ (one per ad). In each iteration be grow $B$ by adding one new matched edge, so we have at most $j$ iterations of the while loop. Therefore, the overall running time is $O(\sum_{j=1}^{n}jnk)=O(n^{3}k)$.

However, we can come up with a more efficient implementation of UpdatePossibleNewEdges$(P,v,\alpha,j^{\prime})$ that exploits the special structure of our valuation function so that $P$ holds at most $n+k$ ads and only $O(k)$ edges incident on $j^{\prime}$ need to be scanned without sacrificing the overall correctness of the algorithm. With this improvement in performance, each iteration of the while loop in Line 7 takes at most $O(\log n+k)$ work. Again, since in each iteration be grow $B$ by adding one new matched edge, we have at most $j$ iteration of the while loop. Therefore, the overall running time is $O(\sum_{j=1}^{n}j(k+\log n))=O(n^{2}(k+\log n))$.

Theorem 3.1**.**

Given an input with $k$ ad types and $n$ slots, Algorithm 1 can be implemented to run in time $O(n^{2}(k+\log n))$.

Our goal for the the rest of this section is to provide an implementation UpdatePossibleNewEdges$(P,v,\alpha,j^{\prime})$ where the size of $P$ is always at most $n+k$ and only $O(k)$ edges are considered in each invocation of the routine. Key to our analysis is the observation that tight edges cannot cross is the following sense: Given two ads $i<i^{\prime}$ of the same type $\theta$, and two slots $j<j^{\prime}$, then we cannot have the edge from ad $i$ to slot $j^{\prime}$ be tight, and simultaneously have the edge from ad $i^{\prime}$ to $j$ be tight.

Lemma 3.2** (Non-crossing lemma).**

Given two ads $i<i^{\prime}$ of the same type $\theta$, and two slots $j<j^{\prime}$, if $v_{i}>v_{i^{\prime}}$ and $\alpha^{(\theta)}_{j}>\alpha^{(\theta)}_{j^{\prime}}$ then in any feasible dual solution we cannot have the edge from ad $i$ to slot $j^{\prime}$ be tight, and simultaneously have the edge from ad $i^{\prime}$ to $j$ be tight.

Proof.

We prove by contradiction. If the edges between $i$ and $j^{\prime}$ and $i^{\prime}$ and $j$ are both tight, then we must have dual variables $u_{i},u_{i^{\prime}},p_{j},p_{j^{\prime}}$ such that

[TABLE]

At the same time, due to the slackness constraints, we must have that

[TABLE]

We can combine these and obtain

[TABLE]

Which is false due to the standard exchange argument. We give the argument for completeness: Rearranging we have $(\alpha^{(\theta)}_{j}-\alpha^{(\theta)}_{j^{\prime}})\cdot(v_{i}-v_{i^{\prime}})\leq 0$; however, due to strict monotonicity $\alpha^{(\theta)}_{j}>\alpha^{(\theta)}_{j^{\prime}}$ and $v_{i}>v_{i^{\prime}}$, so have reached a contradiction. ∎

3.1.1 UpdatePossibleNewEdges

The goal of UpdatePossibleNewEdges$(P,v,\alpha,j^{\prime})$ is to iterate over the edges incident on $j^{\prime}$ that are tight or that can potentially become tight later in the execution of the current phase. For each such edge $(i^{\prime},j^{\prime})$ we compare its slack with the priority associated with $i^{\prime}$ and update the entry for $i^{\prime}$ in $P$ accordingly if needed.

The exact definition of the edges inspected is given by Algorithm 2. Instead of describing how this works, let us make some observations about the set of edges that can potentially become tight, and then we shall see that the Algorithm indeed considers all these edges.

For each ad type $\theta$ we first consider the edges of the form $(a^{(\theta)}_{i},j^{\prime})$ where $a^{(\theta)}_{i}$ is matched and $M(a^{(\theta)}_{i})<j^{\prime}$. We claim that we only need to consider the largest such $i$. Recall that all the edges in $M$ are tight and remain tight throughout the execution of the phase; in particular, $(a^{(\theta)}_{i},M(a^{(\theta)}_{i}))$ is tight and remains tight. Thus, any edge $(a^{(\theta)}_{i^{\prime}},j^{\prime})$ with $i^{\prime}<i)$ is not tight and will never become tight due the Non-crossing Lemma 3.2 and the fact that $i^{\prime}<i$ and $M(a^{(\theta)}_{i})<j^{\prime}$.

Now consider the edges of the form $(a^{(\theta)}_{i},j^{\prime})$ where $a^{(\theta)}_{i}$ is matched and $M(a^{(\theta)}_{i})>j^{\prime}$. We claim that we only need to consider the smallest such $i$. Recall that all the edges in $M$ are tight and remain tight throughout the execution of the phase; in particular, $(a^{(\theta)}_{i},M(a^{(\theta)}_{i}))$ is tight and remains tight. Thus, any edge $(a^{(\theta)}_{i^{\prime}},j^{\prime})$ with $i^{\prime}>i$ is not tight and will never become tight due the Non-crossing Lemma 3.2 and the fact that $i^{\prime}>i$ and $M(a^{(\theta)}_{i})>j^{\prime}$.

Finally, we need to consider edges of the form $(a^{(\theta)}_{i},j^{\prime})$ where $a^{(\theta)}_{i}$ is unmatched. We claim that we only need to consider the smallest such $i$ available777It is worth noting that even this case can be ignored if there exists a matched $a^{(\theta)}_{i}$ such that $M(a^{(\theta)}_{i})>j^{\prime}$; however, for ease of presentation we add the slot to $X$ even if such $a^{(\theta)}_{i}$ exists.. Indeed, for any other $i^{\prime}>i$ note that $v^{(\theta)}_{i}>v^{(\theta)}_{i^{\prime}}$ and since the $u$ variable of both ads is 0 (only slots that are part of an alternating tree get their dual variables increased and those are always matched) the slack of $(a^{(\theta)}_{i},j^{\prime})$ will always be smaller than the slack of $(a^{(\theta)}_{i^{\prime}},j^{\prime})$ since $v^{(\theta)}_{i}\alpha^{(\theta)}_{j^{\prime}}-p_{j^{\prime}}<v^{(\theta)}_{i^{\prime}}\alpha^{(\theta)}_{j^{\prime}}-p_{j^{\prime}}$. Furthermore, notice that if the edge $(a^{(\theta)}_{i},j^{\prime})$ become tight, then we immediately have an augmenting path in $B$, which concludes the phase.

It is easy to see that these three cases are precisely those covered by Algorithm 2.

Lemma 3.3**.**

There can be at most $n+k$ ads in $P$ at any given point in time.

Proof.

Notice that the the only edges $(i^{\prime},j^{\prime})$ that we consider in Line 16 are either to a matched node in $M$ or to the heighest unmatched ad of each type. There are exactly $j<n$ matched ads in phase $j$ and there are $k$ ad types, so the lemma follows. ∎

Lemma 3.4**.**

UpdatePossibleNewEdges* considers only $O(k)$ edges when updating $P$ and these are the only edges we need to look at.*

Proof.

The reason why we can focus just on the edges in Line 14 has already been explained in the description of the algorithm UpdatePossibleNewEdges, so we only need to argue about their number. Clearly, each ad type generated at most three ads into $X$, thus, the number of edges considered when updating $P$ is at most $3k$. ∎

3.2 Large Number of Ad Types

When $k=n$, Algorithm 1 is no faster than running the standard Hungarian algorithm. The following lemma shows that this is to be expected as any instance of the assignment problem can be reduced to an instance where all ads agree on the order of the slots.

Lemma 3.5**.**

With $k=n$ ad types, the problem is no easier to solve than the assignment problem, even with monotone discount curves.

Proof.

We’ll reduce to the assignment problem. Given an instance of the assignment problem (with positive edge values), let $v^{*}=1+\max_{(i,j)\in E}v_{ij}$, indicate one of the sides of the bipartite graph as the slots, and choose an order $\sigma$. For all incident edges to the lowest slot, add [math] to the edge. For the second to last edge, add $v^{*}$ to the edge, for the third to last edge add $2v^{*}$, and so on. The value of any perfect matching has increased by $\frac{m(m-1)}{2}v^{*}$, which is a constant. So the solution to the optimal perfect matching is the same as the original problem. Note that now for each ad, the slots are monotonically decreasing according to order $\sigma$, so for each ad there’s a decomposition into a base value, and a discount for each slot which is monotonically decreasing. ∎

3.3 Computing VCG Prices

Algorithm 1 gives us a fast way to compute the optimal allocation for the Ad Types problem. The VCG mechanism [42, 7, 21] can be use to compute corresponding incentive compatible prices, by running the allocation algorithm $n+1$ times, for a total running time of $O(n^{3}(k+\log n))$. In this section we show that in fact we can compute VCG prices in asymptotically identical time to solving the allocation problem once: $O(n^{2}(k+\log n))$. It is a folk theorem that an instance of the assignment problem can be priced in asymptotically the same time as solving the assignment problem (namely $O(n^{3})$ for balanced bipartite graphs); this section shows that our improved running time carries over as well.

We begin with the well-known fact (e.g. [10, Chapter 15]) that VCG prices and buyer utilities are feasible (and optimal) dual variables for the assignment problem. Additionally, the VCG prices correspond to the point-wise lowest possible dual variables for the slots over all feasible solutions to the dual. Thus, we can find VCG prices by finding the lowest dual variables.

Theorem 3.6**.**

Given an instance $(U,V,E)$ of the assignment problem, along with an optimal matching $M$, and shadow prices $\bf p$. Algorithm 3 computes VCG prices in $O(|E|+|V|\cdot\log|E|)$ time.

Proof.

Algorithm 3 is similar to a single “phase” of Algorithm 1. To find $\Delta$ we use a Fibonnacci heap on the edges where $(i\in R,r\not\in R)$ or $(i\not\in R,r\in R)$. During each while loop, we mark at least one slot as immutable, so the total number running time to find $\Delta$ over the entire algorithm is $O(|V|\log|E|)$.

The alternating BFS trees can only touch each edge ones over the course of all iterations, hence the total time this takes is bounded by $O(|E|)$, finally each node is marked as immutable at most once, hence the total time over all iterations of line 6 is $O(|V|)$. This yields total running time of $O(|E|+|V|\log|E|)$ as claimed. Note that no price could be lower, since all nodes either have price [math] or lowering their price would violate a slackness constraint. Thus, the dual variables for the slot correspond to VCG prices. ∎

Corollary 3.7**.**

Given an instance of the Ad Types problem, we can compute the optimal allocation and VCG prices in $O(n^{2}(k+\log n))$ time.

Proof.

By theorem 3.1 we can compute an optimal allocation in $O(n^{2}(k+\log n))$ time. By Theorem 3.6 and since $|E|=kn^{2}$, from the optimal allocation we can compute the corresponding VCG prices in $O(kn^{2}+n\log kn)$ hence the total time is $O(n^{2}(k+\log n))$ as claimed. ∎

3.4 Applying Reserve Prices

Setting a reserve price, or a minimum bid, is a common way to control revenue [34]. But how can we apply a reserve price in the ad types problem? In our setting, where we have discrete allocation amounts (the discounts $\alpha_{j}^{\theta}$ for an ad of type $\theta$), Myerson’s payment identity boils down to determining the changepoints in the mechanism, given the other bids $b_{-i}$. We could find these changepoints by updating the bid of an advertiser while maintaining the invariants in the Hungarian algorithm, but we present a simpler approach here that may be of independent interest to the mechanism design community. The idea is similar to the externality computation in VCG, but rather than removing the advertiser in the alternative allocation, we compare against an alternative where the advertiser bids their reserve price.

Since this approach works in single-parameter environments beyond the Ad Types Problem, we use the more general notation introduced in Section 2.1. Recall that we have $n$ strategic agents, outcome space $\Omega$, function $x_{i}:\Omega\rightarrow\mathbb{R}$ from outcomes to a quantity of “stuff”, and valuation function $v_{i}(\omega)=x_{i}(\omega)\cdot v_{i}$ where we overload notation and let $v_{i}\in\mathbb{R}$. Additionally, we have agent-specific reserve prices $r_{i}$ below which we won’t serve an agent. Finally, we have black-box access to an algorithm $\mathcal{X}:\mathbb{R}^{n}\rightarrow\Omega$ that given $n$ bids $\bf b$, yields an outcome $\omega$ that maximizes $\sum_{i=0}^{n}v_{i}(\omega)$, the social welfare of strategic agents.

The goal in this setting is to come up with an incentive-compatible pricing scheme to match the social welfare-maximizing (subject to reserve prices) allocation. Due to Myerson, we know that if we can compute the change points in the allocation function, we can recover the (unique up to translation) pricing rule that is incentive compatible. However, generally computing change points may be costly. The goal then is to compute incentive compatible prices without change point computation.

Incentive Compatible Pricing without Changepoint Computation.

The algorithm is given in Algorithm 4, where we overload $\mathcal{X}$ to take the bids of the set passed to it, and we use the notation $\mathcal{X}(b_{i}\rightarrow r_{i},B^{\prime}_{-i})$ to indicate applying $\mathcal{X}$ to the set $B^{\prime}_{-i}$ plus bidder $i$ with their bid replaced by $r_{i}$. In the traditional VCG algorithm, the buyer’s externality is computed by removing them from the auction entirely and charging the change in utility of the remaining buyers. The difference here is that we’re not removing the buyer, but instead we replace their bid by the reserve price. Additionally we charge them $r_{i}$ per unit of stuff they receive if they bid their reserve price. Intuitively this payment scheme corresponds to Myerson payments, where we only explicitly compute the change point at the reserve price, and we implicitly compute reserve prices by looking at the difference in outcomes between bidding $b_{i}$ and $r_{i}$.

Myerson [34] showed that the payments that yield an incentive compatible auction are uniquely determined given an allocation rule, up to an additive constant. Of special interest are payments where losers pay nothing. Therefore, it suffices to show that the payments computed by Algorithm 4 are incentive compatible and charge losers nothing to prove that they are equivalent to applying Myerson’s payment identity. In the following let $SW(B)=\sum_{j\in B}v_{j}\cdot x_{j}(\omega)$ for $\omega=\operatorname*{arg\,max}_{\omega\in\Omega}\sum_{j\in B}b_{j}\cdot x_{j}(\omega)$—i.e. the social welfare of the optimal allocation assuming bids equal values—with $SW(B)=SW_{i}(B)+SW_{-i}(B)$ such that $SW_{i}$ is only the contribution of $i$ to $SW(B)$ and $SW_{-i}(B)$ is the contribution of the remaining bidders $\{j\in B:j\neq i\}$. Similarly, let $SW(b_{i}\rightarrow r_{i},B_{-i})=\sum_{j\in B}v_{j}\cdot x_{j}(\omega^{\prime})$ for $\omega^{\prime}=\operatorname*{arg\,max}_{\omega\in\Omega}r_{i}\cdot x_{i}(\omega)+\sum_{j\in B,j\neq i}b_{j}\cdot x_{j}(\omega)$ i.e. the social welfare of the optimal allocation assuming bids equal values and $b_{i}$ replaced by $r_{i}$, with $SW_{i}(b_{i}\rightarrow r_{i},B_{-i})$ and $SW_{-i}(b_{i}\rightarrow r_{i},B_{-i})$ defined analogously.

Theorem 3.8**.**

Algorithm 4 yields the unique Incentive Compatible pricing scheme for $\mathcal{X}$ with eager reserves that charges losers [math].

Proof.

[TABLE]

We treat the cases for $v_{i}<r_{i}$ and $v_{i}\geq r_{i}$ separately.

If $v_{i}<r_{i}$, then $u_{i}(b_{i},b_{-i})=0$ for all $b_{i}<r_{i}$, so there’s no beneficial deviation from $b_{i}=v_{i}$ to some other $b_{i}<r_{i}$. Moreover, bidding $b_{i}>r_{i}$ can only yield negative utility: first observe that if $b_{i}=r_{i}$, it must hold that $SW(B^{\prime})\leq SW(b_{i}\rightarrow r_{i},B^{\prime}_{-i})$ by definition since the latter is the optimal social welfare achievable (if $b_{i}=r_{i}$), hence the former can only be lower. This implies that the utility must be non-positive for any $v_{i}\leq r_{i}$ since the value per-quantity good is lower than if $v_{i}=r_{i}$ but the price stays the same. So for $v_{i}<r_{i}$ there is no beneficial deviation.

If $b_{i}\geq r_{i}$, notice that the term $SW(b_{i}\rightarrow r_{i},B^{\prime}_{-i})$ is independent of the bid of bidder $i$. So the only relevant term is $SW(B^{\prime})$. Since $\mathcal{X}$ compute the maximum-weight bipartite matching given the bids, bidding $v_{i}$ yields the maximum utility; hence no other bid $b_{i}\geq r_{i}$ can improve utility. Moreover, since the utility is guaranteed to be non-negative, bidding $b_{i}<r_{i}$ (which yields $u_{i}=0$) cannot increase utility.

So in all cases, a bidder maximizes their utility by bidding $v_{i}$. Moreover, in both cases, if $x_{i}(\omega)=0$, the bidder pays nothing, so Algorithm 4 yields the unique incentive compatible prices where losers pay 0. ∎

Thus, if we use Algorithm 1 to compute the max-weight bipartite matching after applying reserve prices, Algorithm 4 runs in $O(n^{3}(k+\log n))$.

Corollary 3.9**.**

Algorithm 4 runs in $O(n^{3}(k+\log n))$ for the Ad Types Problem without gap rules.

4 The Ad Types Problem with Gap Rules

In this section we switch our attention to the full version of the Ad Types problem where we do have gap rules. As we shall see, this problem is much harder if we do not place any restriction on the instances. On the positive side, we show that the problem is fixed parameter tractable on the number of ad types.

4.1 Hardness

In this subsection we prove that even approximating an optimal allocation for the Ad Types problem with Gap Rules is hard, even when there are no discount curves.

Theorem 4.1**.**

The Ad Types problem with Gap Rules hard to approximate better than $k^{1-\epsilon}$ for any $\epsilon>0$, unless P = NP, even when the discount curves of all the ad types are identically equal to $1$.

Proof.

The proof reduces the Maximum Independent Set (MIS) problem to the Ad Types problem. In the MIS problem we have a graph $(V,E)$ and we want to find the largest subset of vertices such that no two vertices are connected with an edge.

Given an instance of the MIS problem, we can build an instance of the Ad Types problem as follows:

• •

Let the number of slots and the number ad types equal the number of vertices in the MIS problem, i.e., $k=n=|V|$.

• •

Each ad type has exactly one ad in it, i.e., for each $\theta_{l}$ for $l\in\{1,\ldots,k\}$, $|A^{\theta_{l}}|=1$.

• •

Each ad has value-per-conversion equal to $1$, i.e. $\forall l\in\{1,\ldots,k\}$, $v^{(\theta_{l})}=1$. Notice that we dropped the subscript over $v$, since there is only one ad per ad type.

• •

The ads have no discount curves over the slots, i.e., $\alpha_{1}^{\theta_{l}}=\ldots=\alpha_{k}^{\theta_{l}}=1$ $\forall l\in\{1,\ldots,k\}$.

• •

Let $G$ be the $k\times k$ matrix describing the gap rule. The gap between two ad types $i$ and $j$ is $k$ if $(i,j)\in E$ and [math] otherwise, i.e., $G_{ij}=k$ if $(i,j)\in E$ and $G_{ij}=0$ otherwise.

Given the construction of the gap rules, two ads can belong to a solution of the Ad Types problem only if their corresponding vertices are not connected in $G$. Since all the ads have value $1$ for all the slots, a solution of the Ad Types problem represents how many ads have been allocated. Moreover, each allocated ad contributes 1 to the wellfare objective of the Ad Types problem so maximizing the value of the allocation for the Ad Types problem is equivalent to maximizing the size of the correspondign independent set. Thus, the Ad Types problems inherets the $k^{1-\epsilon}$ hardness of approximation of MIS [24, 43] since $|V|=k$.

∎

4.2 Exact Algorithm

Since the previous section shown that the Ad Types Problem with Gap Rules cannot be solved in polynomial time, unless $P=NP$, here we provide a dynamic-programming based algorithm that solves the problem exactly in exponential time.

The dynamic program has $2k$ dimensions. For each ad type $l$ the dynamic program stores (i) the number of ads of type $\theta_{l}$ that have been allocated, and (ii) the largest slot index that an ad of type $\theta_{l}$ has been allocated.

As usual, we assume that within each ad type, the ads monotonically decrease in valuation, i.e., for each $\theta_{l},$ $v_{1}^{\theta_{l}}\geq v_{2}^{\theta_{l}}\geq\ldots\geq v_{n}^{\theta_{l}}$.

In order to describe our dynamic program, we need some additional notation:

• •

let $n^{\theta_{l}}$ be the number of ads allocated for the ad type $\theta_{l}$, we denote these values with a vector $\bm{n^{\theta}}=\langle n^{\theta_{1}},\ldots,n^{\theta_{k}}\rangle$

• •

let $s^{\theta_{l}}$ be the last slot where an ad of type $\theta_{l}$ has been allocated, we denote these values with a vector $\bm{s^{\theta}}=\langle s^{\theta_{1}},\ldots,s^{\theta_{k}}\rangle$

• •

for a given vector $\bm{a}$, let $\bm{a_{-l,x}}$ to denote a new vector where the $l$th coordinate is replaced by $x$, i.e., if $\bm{a}=\langle a_{1},\ldots,a_{k}\rangle$ then $\bm{a_{-l,x}}=\langle a_{1},\ldots,a_{l-1},x,a_{l+1},\ldots,a_{k}\rangle$

Let $T[\bm{n^{\theta}},\bm{s^{\theta}}]$ be our dynamic program states, which we define to be maximum value among allocations that assigns $n^{\theta_{l}}$ ads of type $\theta_{l}$ with the last ad being assigned to slot $s^{\theta_{l}}$. We allow $s^{\theta}_{l}$ to be empty (which we can denote with the special symbol $\perp$) to handle the case where $n^{\theta}_{l}=0$.

To derive the recurrence for our DP formulation, let us focus on a type $\theta_{l}$ with largest $s^{\theta}_{l}$ value. Given that the last ad of type $\theta_{l}$ is in $s^{\theta}_{l}$, let us denote with $P(\theta_{l},\bm{n^{\theta}},\bm{s^{\theta}})$ the set of possible slots where we could have the second to last ad of type $\theta_{l}$. If $n^{\theta}_{l}=1$ then $P(\theta_{l},\bm{n^{\theta}},\bm{s^{\theta}})=\{\perp\}$, otherwise, it contains every slot that obeys all the gap rules between this new ad and the ads locations specified by $\bm{s^{\theta}}$.

[TABLE]

The base case of the recurrence is when $\bm{n^{\theta}}$ is the all 0 vector and $\bm{s^{\theta}}$ is the all empty-position vector. If we ever reach a state where $P(\theta_{l},\bm{n^{\theta}},\bm{s^{\theta}})=\emptyset$ then the state is infeasible so we set its cost to be $-\infty$. The optimal solution will be at a state with highest value.

Theorem 4.2**.**

The Ad Types Problem can solved optimally in $O(k\cdot n^{2k+1})$ time.

Proof.

The correctness of the dynamic programming formulation follows from the fact that for any of the states on the right hand side of (1) any allocation that is consistent to the state can be augmented by allocating the $n^{\theta_{l}}$th ad of type $\theta_{l}$ to slot $s^{\theta_{l}}$ due to the fact that $\theta_{l}$ has the largest $s^{\theta_{l}}$ value.

We only consider states where $s^{\theta_{l}}\leq n$ and $n^{\theta_{l}}\leq n$ for all types $\theta_{l}$, so the DP table has $n^{2k}$ entries. Each entry takes $O(kn)$ time to compute (there are $n$ possible slots in $P(\cdot)$ and each one takes $O(k)$ to check whether it obeys the gaps rules), so the total running time is $O(k\cdot n^{2k+1})$. ∎