The Complexity of Optimal Multidimensional Pricing

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2011 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Improved Approximation Results for Stochastic Knapsack ProblemsAnand Bhalgat, Ashish Goel, and Sanjeev KhannaAnand Bhalgat, Ashish Goel, and Sanjeev Khannapp.1647 - 1665Chapter DOI:https://doi.org/10.1137/1.9781611973082.127PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract In the stochastic knapsack problem, we are given a set of items each associated with a probability distribution on sizes and a profit, and a knapsack of unit capacity. The size of an item is revealed as soon as it is inserted into the knapsack, and the goal is to design a policy that maximizes the expected profit of items that are successfully inserted into the knapsack. The stochastic knapsack problem is a natural generalization of the classical knapsack problem, and arises in many applications, including bandwidth allocation, budgeted learning, and scheduling. An adaptive policy for stochastic knapsack specifies the next item to be inserted based on observed sizes of the items inserted thus far. The adaptive policy can have an exponentially large explicit description and is known to be PSPACE-hard to compute. The best known approximation for this problem is a (3 + ∊)-approximation for any ∊ > 0. Our first main result is a relaxed PTAS (Polynomial Time Approximation Scheme) for the adaptive policy, that is, for any ∊ > 0, we present a poly-time computable (1 + ∊)-approximate adaptive policy when knapsack capacity is relaxed to 1+e. At a high-level, the proof is based on transforming an arbitrary collection of item size distributions to canonical item size distributions that admit a compact description. We then establish a coupling that shows a (1 + ∊)-approximation can be achieved for the original problem by a canonical policy that makes decisions at each step by observing events drawn from the sample space of canonical size distributions. Finally, we give a mechanism for approximating the optimal canonical policy. Our second main result is an (8/3 + ∊)-approximate adaptive policy for any ∊ > 0 without relaxing the knapsack capacity, improving the earlier (3 + ∊)-approximation result. Interestingly, we obtain this result by using the PTAS described above. We establish an existential result that the optimal policy for the knapsack with capacity 1 can be folded to get a policy with expected profit 3OPT/8 for a knapsack with capacity (1 − ∊), with capacity relaxed to 1 only for the first item inserted. We then use our PTAS result to compute the (1 + ∊)-approximation to such policy. Our techniques also yield a relaxed PTAS for non-adaptive policies. Finally, we also show that our ideas can be extended to yield improved approximation guarantees for multi-dimensional and fixed set variants of the stochastic knapsack problem. Previous chapter Next chapter RelatedDetails Published:2011ISBN:978-0-89871-993-2eISBN:978-1-61197-308-2 https://doi.org/10.1137/1.9781611973082Book Series Name:ProceedingsBook Code:PR138Book Pages:xviii-1788

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms (SODA)Faster p-norm minimizing flows, via smoothed q-norm problemsDeeksha Adil and Sushant SachdevaDeeksha Adil and Sushant Sachdevapp.892 - 910Chapter DOI:https://doi.org/10.1137/1.9781611975994.54PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We present faster high-accuracy algorithms for computing ℓp-norm minimizing flows. On a graph with m edges, our algorithm can compute a (1 + 1/poly(m))-approximate unweighted ℓp-norm minimizing flow with operations, for any p ≥ 2, giving the best bound for all p ≳ 5.24. Combined with the algorithm from the work of Adil et al. (SODA '19), we can now compute such flows for any 2 ≤ p ≤ mo(1) in time at most O(m1.24). In comparison, the previous best running time was Ω(m1.33) for large constant p. For p ∼ σ−1 log m, our algorithm computes a (1 + σ)-approximate maximum flow on undirected graphs using m1+o(1)σ−1 operations, matching the current best bound, albeit only for unit-capacity graphs. We also give an algorithm for solving general ℓp-norm regression problems for large p. Our algorithm makes calls to a linear solver. This gives the first high-accuracy algorithm for computing weighted ℓp-norm minimizing flows that runs in time o(m1.5) for some p = mΩ(1). Our key technical contribution is to show that smoothed ℓp-norm problems introduced by Adil et al., are interreducible for different values of p. No such reduction is known for standard ℓp-norm problems. Previous chapter Next chapter RelatedDetails Published:2020eISBN:978-1-61197-599-4 https://doi.org/10.1137/1.9781611975994Book Series Name:ProceedingsBook Code:PRDA20Book Pages:xxii + 3011

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2014 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Partitioning into ExpandersShayan Oveis Gharan and Luca TrevisanShayan Oveis Gharan and Luca Trevisanpp.1256 - 1266Chapter DOI:https://doi.org/10.1137/1.9781611973402.93PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract Let G = (V, E) be an undirected graph, λk be the kth smallest eigenvalue of the normalized laplacian matrix of G. There is a basic fact in algebraic graph theory that λk > 0 if and only if G has at most k – 1 connected components. We prove a robust version of this fact. If λk > 0, then for some 1 ≤ ℓ ≤ k – 1, V can be partitioned into ℓ sets P1, …, Pℓ such that each Pi is a low-conductance set in G and induces a high conductance induced subgraph. In particular, and G[Pi] ≳ λk/k2-expander. We make our results algorithmic by designing a simple polynomial time spectral algorithm to find such partitioning of G with a quadratic loss in the inside conductance of Pi's. Unlike the recent results on higher order Cheeger's inequality [6, 9], our results does not use higher order eigenfunctions of G. If there is a sufficiently large gap between λk and λk+1, more precisely if then our algorithm finds a k partitioning of V into sets P1, …, Pk such that the induced subgraph G[Pi] has a singnificantly larger conductance than the conductance of Pi in G. Such a partitioning may represent the best k clusterings of G. Our algorithm is a simple local search that only uses the Spectral Partitioning algorithm as a subroutine. We expect to see further applications of this simple algorithm in clustering applications. Let ρ(k) = mindisjoint max1≤i≤k φ(Ai) be the order k conductance constant of G, in words, ρ(k) is the smallest value of the maximum conductance of any k disjoint subsets of V. Our main technical lemma shows that if (1 + ∊)ρ(k) < ρ(k+1), then V can be partitioned into k sets P1, …, Pk such that for each 1 ≤ i ≤ k, φ(G[Pi]) ≳ ∊ · ρ(k + 1)/k and φ(Pi) ≤ k · ρ(k). This significantly improves a recent result of Tanaka [13] who assumed an exponential (in k) gap between ρ(k) and ρ(k + 1). Previous chapter Next chapter RelatedDetails Published:2014ISBN:978-1-61197-338-9eISBN:978-1-61197-340-2 https://doi.org/10.1137/1.9781611973402Book Series Name:ProceedingsBook Code:PRDA14Book Pages:viii + 1885

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2012 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Inapproximability of the Multi-level Uncapacitated Facility Location ProblemRavishankar Krishnaswamy and Maxim SviridenkoRavishankar Krishnaswamy and Maxim Sviridenkopp.718 - 734Chapter DOI:https://doi.org/10.1137/1.9781611973099.59PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract In this paper, we present improved inapproximability results for the k-level uncapacitated facility location problem. In particular, we show that there is no polynomial time approximation algorithm with performance guarantee better than 1.539 unless NP is contained in DTIME(nO(log log n)) for the case when k = 2. For the case of general k (tendining to infinity) we obtain a better hardness factor of 1.61. Interestingly, our results show that the two-level problem is computationally harder than the well known uncapacitated facility location problem (k = 1) since the best known approximation guarantee for the latter problem is 1.488 due to Li [22], and our inapproximability is a factor of 1.539 for the two-level problem. The only inapproximability result known before for this class of metric facility location problems is the bound of 1.463 due to Guha and Khuller [17], which holds even for the case of k = 1. Previous chapter Next chapter RelatedDetails Published:2012ISBN:978-1-61197-210-8eISBN:978-1-61197-309-9 https://doi.org/10.1137/1.9781611973099Book Series Name:ProceedingsBook Code:PR141Book Pages:xiii + 1757

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2009 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Exact Algorithms for Partial Curve Matching via the Fréchet DistanceKevin Buchin, Maike Buchin, and Yusu WangKevin Buchin, Maike Buchin, and Yusu Wangpp.645 - 654Chapter DOI:https://doi.org/10.1137/1.9781611973068.71PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract Curve matching is a fundamental problem that occurs in many applications. In this paper, we study the problem of measuring partial similarity between curves. Specifically, given two curves, we wish to maximize the total length of subcurves that are close to each other, where closeness is measured by the Fréchet distance, a common distance measure for curves. The resulting maximal length is called the partial Fréchet similarity between the two input curves. Given two polygonal curves P and Q in IRd of size m and n, respectively, we present the first exact algorithm that runs in polynomial time to compute ℱδ(P, Q), the partial Fréchet similarity between P and Q, under the L1 and L∞ norms. Specifically, we formulate the problem of computing ℱδ(P, Q) as a longest path problem, and solve it in O(mn(m + n) log(mn)) time, under the L1 or L∞ norm, using a “shortest-path map” type decomposition. To the best of our knowledge, this is the first paper to study this natural definition of partial curve similarity in the continuous setting (with all points in the curve considered), and present a polynomial-time exact algorithm for it. Previous chapter Next chapter RelatedDetails Published:2009ISBN:978-0-89871-680-1eISBN:978-1-61197-306-8 https://doi.org/10.1137/1.9781611973068Book Series Name:ProceedingsBook Code:PR132Book Pages:xviii + 1288

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2013 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Near Optimal Leader Election in Multi-Hop Radio NetworksMohsen Ghaffari and Bernhard HaeuplerMohsen GhaffariMITMITSearch for more papers by this author and Bernhard HaeuplerMITMITSearch for more papers by this authorpp.748 - 766Chapter DOI:https://doi.org/10.1137/1.9781611973105.54PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We design leader election protocols for multi-hop radio networks that elect a leader in almost the same time TBC that it takes for broadcasting one message (one ID). For the setting without collision detection our algorithm runs whp. in rounds on any n-node network with diameter D. Since is a lower bound, our upper bound is optimal up to a factor of at most log log n and the extra log n factor on the additive term. Our algorithm is furthermore the first O(n) time algorithm for this setting. Our algorithm improves over a 23 year old simulation approach of Bar-Yehuda, Goldreich and Itai with a O(TBC log n) running time: In 1987 they designed a fast broadcast protocol and subsequently in 1989 they showed how it can be used to simulate one round of a single-hop network that has collision detection in TBC time. The prime application of this simulation was to simulate Willards single-hop leader election protocol, which elects a leader in O(log n) rounds whp. and O(log log n) rounds in expectation. While it was subsequently shown that Willards bounds are tight, it was unclear whether the simulation approach is optimal. Our results break this barrier and essentially remove the logarithmic slowdown over the broadcast time TBC. This is achieved by going away from the simulation approach. We also give an leader election algorithm for the setting with collision detection (even with single-bit messages). This is optimal up to log log n factors and improves over a deterministic algorithm that requires Θ(n) rounds independently of D. Our almost optimal leader election protocols are especially important because countless communication protocols in radio networks use leader election as a crucial first step to solve various, seemingly unrelated, communication primitives such as gathering, multiple unicasts or multiple broadcasts. Even though leader election seems easier than these tasks, its best-known O(TBC log n) running time had become a bottleneck, preventing optimal algorithms. Breaking the simulation barrier for leader election in this paper has subsequently led to the development of near optimal protocols for these communication primitives. Previous chapter Next chapter RelatedDetails Published:2013ISBN:978-1-61197-251-1eISBN:978-1-61197-310-5 https://doi.org/10.1137/1.9781611973105Book Series Name:ProceedingsBook Code:PR143Book Pages:xix + 1915

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2012 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Using Hashing to Solve the Dictionary Problem (In External Memory)John Iacono and Mihai PătraşcuJohn IaconoPolytechnic Institute of NYUAT&T Labs*Research supported by NSF grants CCF-1018370, CCF-0430849 and by an Alfred P. Sloan fellowship. Research partially completed as a visiting professor at MADALGO (Center for Massive Data Algorithmics, a Center of the Danish National Research Foundation), Department of Computer Science, Aarhus University, IT Parken, Åbogade 34, DK-8200 Århus N, Denmark.Search for more papers by this author and Mihai PătraşcuPolytechnic Institute of NYUAT&T LabsSearch for more papers by this authorpp.570 - 582Chapter DOI:https://doi.org/10.1137/1.9781611973099.48PDFBibTexSections ToolsAdd to favoritesDownload CitationsTrack CitationsEmail SectionsAboutAbstract We consider the dictionary problem in external memory and improve the update time of the well-known buffer tree by roughly a logarithmic factor. For any λ > max(lg lg n, logM/B (n/B)}, we can support updates in time O(λ/B) and queries in sublogarithmic time, O(logλ n). We also present a lower bound in the cell-probe model showing that our data structure is optimal. In the RAM, hash tables have been use to solve the dictionary problem faster than binary search for more than half a century. By contrast, our data structure is the first to beat the comparison barrier in external memory. Ours is also the first data structure to depart convincingly from the indivisibility paradigm. Previous chapter Next chapter RelatedDetails Published:2012ISBN:978-1-61197-210-8eISBN:978-1-61197-309-9 https://doi.org/10.1137/1.9781611973099Book Series Name:ProceedingsBook Code:PR141Book Pages:xiii + 1757

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2014 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Half-integrality, LP-branching and FPT AlgorithmsMagnus WahlströmMagnus WahlströmRoyal Holloway, University of London.Search for more papers by this authorpp.1762 - 1781Chapter DOI:https://doi.org/10.1137/1.9781611973402.128PDFBibTexSections ToolsAdd to favoritesDownload CitationsTrack CitationsEmail SectionsAboutAbstract A recent trend in parameterized algorithms is the application of polytope tools (specifically, LP-branching) to FPT algorithms (e.g., Cygan et al., 2011; Narayanaswamy et al., 2012). Though the list of work in this direction is short, the results are already interesting, yielding significant speedups for a range of important problems. However, the existing approaches require the underlying polytope to have very restrictive properties, including half-integrality and Nemhauser-Trotter-style persistence properties. To date, these properties are essentially known to hold only for two classes of polytopes, covering the cases of Vertex Cover (Nemhauser and Trotter, 1975) and Node Multiway Cut (Garg et al., 1994). Taking a slightly different approach, we view half-integrality as a discrete relaxation of a problem, e.g., a relaxation of the search space from {0,1}V to {0,½,1}V such that the new problem admits a polynomial-time exact solution. Using tools from CSP (in particular Thapper and Živný, 2012) to study the existence of such relaxations, we are able to provide a much broader class of half-integral polytopes with the required properties. Our results unify and significantly extend the previously known cases. In addition to the new insight into problems with half-integral relaxations, our results yield a range of new and improved FPT algorithms, including an O*(|Σ|2k)-time algorithm for node-deletion Unique Label Cover with label set Σ (improving the previous bound of due to Chitnis et al., 2012) and an O*(4k)-time algorithm for Group Feedback Vertex Set, including the setting where the group is only given by oracle access (improving on the previous bound of O*(2O(klogk)) due to Cygan et al., 2012). The latter bound is optimal under the Exponential Time Hypothesis. The latter result also implies the first single-exponential time FPT algorithm for Subset Feedback Vertex Set, answering an open question of Cygan et al. (2012). Interestingly, despite the half-integrality, our result do not imply any approximation results (as may be expected, given the Unique Games-hardness of the covered problems). Previous chapter Next chapter RelatedDetails Published:2014ISBN:978-1-61197-338-9eISBN:978-1-61197-340-2 https://doi.org/10.1137/1.9781611973402Book Series Name:ProceedingsBook Code:PRDA14Book Pages:viii + 1885

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2011 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Efficient algorithms for some special cases of the polynomial equivalence problemNeeraj KayalNeeraj Kayalpp.1409 - 1421Chapter DOI:https://doi.org/10.1137/1.9781611973082.108PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We consider the following computational problem. Let F be a field. Given two n-variate polynomials f(x1, …, xn) and g(x1, …, xn) over the field F, is there an invertible linear transformation of the variables which sends f to g? In other words, can we substitute a linear combination of the xi's for each xj appearing in f and obtain the polynomial g? This problem is known to be at least as difficult as the graph isomorphism problem even for homogeneous degree three polynomials. There is even a cryptographic authentication scheme (Patarin, 1996) based on the presumed average-case hardness of this problem. Here we show that at least in certain (interesting) special cases there is a polynomial-time randomized algorithm for determining this equivalence, if it exists. Somewhat surprisingly, the algorithms that we present are efficient even if the input polynomials are given as arithmetic circuits. As an application, we show that if in the key generation phase of Patarin's authentication scheme, a random multilinear polynomial is used to generate the secret, then the scheme can be broken and the secret recovered in randomized polynomial-time. Previous chapter Next chapter RelatedDetails Published:2011ISBN:978-0-89871-993-2eISBN:978-1-61197-308-2 https://doi.org/10.1137/1.9781611973082Book Series Name:ProceedingsBook Code:PR138Book Pages:xviii-1788

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2012 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Sequential Auctions and ExternalitiesRenato Paes Leme, Vasilis Syrgkanis, and Eva TardosRenato Paes Leme, Vasilis Syrgkanis, and Eva Tardospp.869 - 886Chapter DOI:https://doi.org/10.1137/1.9781611973099.70PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract In many settings agents participate in multiple different auctions that are not necessarily implemented simultaneously. Future opportunities affect strategic considerations of the players in each auction, introducing externalities. Motivated by this consideration, we study a setting of a market of buyers and sellers, where each seller holds one item, bidders have combinatorial valuations and sellers hold item auctions sequentially. Our results are qualitatively different from those of simultaneous auctions, proving that simultaneity is a crucial aspect of previous work. We prove that if sellers hold sequential first price auctions then for unit-demand bidders (matching market) every subgame perfect equilibrium achieves at least half of the optimal social welfare, while for submodular bidders or when second price auctions are used, the social welfare can be arbitrarily worse than the optimal. We also show that a first price sequential auction for buying or selling a base of a matroid is always efficient, and implements the VCG outcome. An important tool in our analysis is studying first and second price auctions with externalities (bidders have valuations for each possible winner outcome), which can be of independent interest. We show that a Pure Nash Equilibrium always exists in a first price auction with externalities. Previous chapter Next chapter RelatedDetails Published:2012ISBN:978-1-61197-210-8eISBN:978-1-61197-309-9 https://doi.org/10.1137/1.9781611973099Book Series Name:ProceedingsBook Code:PR141Book Pages:xiii + 1757

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2009 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Weighted flow time does not admit O(1)-competitive algorithmsNikhil Bansal and Ho-Leung ChanNikhil BansalIBM T. J. Watson Research CenterMax-Planck-Institut für InformatikSearch for more papers by this author and Ho-Leung ChanIBM T. J. Watson Research CenterMax-Planck-Institut für InformatikSearch for more papers by this authorpp.1238 - 1244Chapter DOI:https://doi.org/10.1137/1.9781611973068.134PDFBibTexSections ToolsAdd to favoritesDownload CitationsTrack CitationsEmail SectionsAboutAbstract We consider the classic online scheduling problem of minimizing the total weighted flow time on a single machine with preemptions. Here, each job j has an arbitrary arrival time rj, weight wj and size pj, and given a schedule its flow time is defined as the duration of time since its arrival until it completes its service requirement. The first non-trivial algorithms with poly-logarithmic competitive ratio for this problem were obtained relatively recently, and it was widely believed that the problem admits a constant factor competitive algorithm. In this paper, we show an ω(1) lower bound on the competitive ratio of any deterministic online algorithm. Our result is based on a gap amplification technique for online algorithms. Starting with a trivial lower bound of 1, we give a procedure to improve the lower bound sequentially, while ensuring at each step that the size of the instance increases relatively modestly. Previous chapter Next chapter RelatedDetails Published:2009ISBN:978-0-89871-680-1eISBN:978-1-61197-306-8 https://doi.org/10.1137/1.9781611973068Book Series Name:ProceedingsBook Code:PR132Book Pages:xviii + 1288

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Deterministic algorithms for the Lovász Local Lemma: simpler, more general, and more parallelDavid G. HarrisDavid G. Harrispp.1744 - 1779Chapter DOI:https://doi.org/10.1137/1.9781611977073.71PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract The Lovász Local Lemma (LLL) is a keystone principle in probability theory, guaranteeing the existence of configurations which avoid a collection ℬ of “bad” events which are mostly independent and have low probability. In its simplest “symmetric” form, it asserts that whenever a bad-event has probability p and affects at most d bad-events, and epd < 1, then a configuration avoiding all ℬ exists. A seminal algorithm of Moser & Tardos (2010) (which we call the MT algorithm) gives nearly-automatic randomized algorithms for most constructions based on the LLL. However, deterministic algorithms have lagged behind. We address three specific shortcomings of the prior deterministic algorithms. First, our algorithm applies to the LLL criterion of Shearer (1985); this is more powerful than alternate LLL criteria and also removes a number of nuisance parameters and leads to cleaner and more legible bounds. Second, we provide parallel algorithms with much greater flexibility in the functional form of the bad-events. Third, we provide a derandomized version of the MT-distribution, that is, the distribution of the variables at the termination of the MT algorithm. We show applications to non-repetitive vertex coloring, independent transversals, strong coloring, and other problems. These give deterministic algorithms which essentially match the best previous randomized sequential and parallel algorithms. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Tight Guarantees for Multi-unit Prophet Inequalities and Online Stochastic KnapsackJiashuo Jiang, Will Ma, and Jiawei ZhangJiashuo Jiang, Will Ma, and Jiawei Zhangpp.1221 - 1246Chapter DOI:https://doi.org/10.1137/1.9781611977073.51PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract Prophet inequalities are a useful tool for designing online allocation procedures and comparing their performance to the optimal offline allocation. In the basic setting of k-unit prophet inequalities, the procedure of Alaei [2] with its celebrated performance guarantee of has found widespread adoption in mechanism design and general online allocation problems in online advertising, healthcare scheduling, and revenue management. Despite being commonly used for implementing a fractional allocation in an online fashion, the tightness of Alaei's procedure for a given k has remained unknown. In this paper we resolve this question, characterizing the tight bound by identifying the structure of the optimal online implementation, and consequently improving the best-known guarantee for k-unit prophet inequalities for all k > 1. We also consider the more general online stochastic knapsack problem where each individual allocation can consume an arbitrary fraction of the initial capacity. Here we introduce a new “best-fit” procedure for implementing a fractionally-feasible knapsack solution online, with a performance guarantee of ≈ 0.319, which we also show is tight with respect to the standard LP relaxation. This improves the previously best-known guarantee of 0.2 for online knapsack. Our analysis differs from existing ones by eschewing the need to split items into “large” or “small” based on capacity consumption, using instead an invariant for the overall utilization on different sample paths. All in all, our results imply tight (non-greedy) Online Contention Resolution Schemes for k-uniform matroids and the knapsack polytope, respectively, which has further implications. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Robust Secretary and Prophet Algorithms for Packing Integer ProgramsC.J. Argue, Anupam Gupta, Marco Molinaro, and Sahil SinglaC.J. Argue, Anupam Gupta, Marco Molinaro, and Sahil Singlapp.1273 - 1297Chapter DOI:https://doi.org/10.1137/1.9781611977073.53PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We study the problem of solving Packing Integer Programs (PIPs) in the online setting, where columns in [0, 1]d of the constraint matrix are revealed sequentially, and the goal is to pick a subset of the columns that sum to at most B in each coordinate while maximizing the objective. Excellent results are known in the secretary setting, where the columns are adversarially chosen, but presented in a uniformly random order. However, these existing algorithms are susceptible to adversarial attacks: they try to “learn” characteristics of a good solution, but tend to over-fit to the model, and hence a small number of adversarial corruptions can cause the algorithm to fail. In this paper, we give the first robust algorithms for Packing Integer Programs, specifically in the recently proposed Byzantine Secretary framework [BGSZ20]. Our techniques are based on a two-level use of online learning, to robustly learn an approximation to the optimal value, and then to use this robust estimate to pick a good solution. These techniques are general and we use them to design robust algorithms for PIPs in the prophet model as well, specifically in the Prophet-with-Augmentations framework [ISW20]. We also improve known results in the Byzantine Secretary framework: we make the non-constructive results algorithmic and improve the existing bounds for single-item and matroid constraints. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Sparsifying, Shrinking and Splicing for Minimum Path Cover in Parameterized Linear TimeManuel Cáceres, Massimo Cairo, Brendan Mumey, Romeo Rizzi, and Alexandru I. TomescuManuel Cáceres, Massimo Cairo, Brendan Mumey, Romeo Rizzi, and Alexandru I. Tomescupp.359 - 376Chapter DOI:https://doi.org/10.1137/1.9781611977073.18PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract A minimum path cover (MPC) of a directed acyclic graph (DAG) G = (V, E) is a minimum-size set of paths that together cover all the vertices of the DAG. Computing an MPC is a basic polynomial problem, dating back to Dilworth's and Fulkerson's results in the 1950s. Since the size k of an MPC (also known as the width) can be small in practical applications, research has also studied algorithms whose running time is parameterized on k. We obtain two new MPC parameterized algorithms for DAGs running in time O(k2|V| log |V| + |E|) and O(k3|V| + |E|). We also obtain a parallel algorithm running in O(k2|V| + |E|) parallel steps and using O(log |V|) processors (in the PRAM model). Our latter two algorithms are the first solving the problem in parameterized linear time. Finally, we show that we can transform (in O(k2|V|) time) a given MPC into another MPC that uses less than 2|V| distinct edges, which we prove to be asymptotically tight. As such, we also obtain edge sparsification algorithms preserving the width of the DAG with the same running time as our MPC algorithms. At the core of all our algorithms we interleave the usage of three techniques: transitive sparsification, shrinking of a path cover, and the splicing of a set of paths along a given path. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771