Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Greediness is not always a vice: Efficient Discovery Algorithms for Assignment Problems

Romaric Duvignau, Noël Gillet, Ralf Klasing

TL;DR

This work introduces the ``discovery'' variant considering edge weights that are not provided as input but must be queried, requiring additional and costly computations, and develops here discovery algorithms aiming to minimize the number of queried weights while providing guarantees on the computed solution.

Abstract

Finding a maximum-weight matching is a classical and well-studied problem in computer science, solvable in cubic time in general graphs. We consider the specialization called assignment problem where the input is a bipartite graph, and introduce in this work the ``discovery'' variant considering edge weights that are not provided as input but must be queried, requiring additional and costly computations. We develop here discovery algorithms aiming to minimize the number of queried weights while providing guarantees on the computed solution. We first show in this work the inherent challenges of designing discovery algorithms for general assignment problems. We then provide and analyze several efficient greedy algorithms that can make use of natural assumptions about the order in which the nodes are processed by the algorithms. Our motivations for exploring this problem stem from finding practical solutions to a variation of maximum-weight matching in bipartite hypergraphs, a problem recently emerging in the formation of peer-to-peer energy sharing communities.

Greediness is not always a vice: Efficient Discovery Algorithms for Assignment Problems

TL;DR

This work introduces the ``discovery'' variant considering edge weights that are not provided as input but must be queried, requiring additional and costly computations, and develops here discovery algorithms aiming to minimize the number of queried weights while providing guarantees on the computed solution.

Abstract

Finding a maximum-weight matching is a classical and well-studied problem in computer science, solvable in cubic time in general graphs. We consider the specialization called assignment problem where the input is a bipartite graph, and introduce in this work the ``discovery'' variant considering edge weights that are not provided as input but must be queried, requiring additional and costly computations. We develop here discovery algorithms aiming to minimize the number of queried weights while providing guarantees on the computed solution. We first show in this work the inherent challenges of designing discovery algorithms for general assignment problems. We then provide and analyze several efficient greedy algorithms that can make use of natural assumptions about the order in which the nodes are processed by the algorithms. Our motivations for exploring this problem stem from finding practical solutions to a variation of maximum-weight matching in bipartite hypergraphs, a problem recently emerging in the formation of peer-to-peer energy sharing communities.

Paper Structure

This paper contains 30 sections, 20 theorems, 9 equations, 11 figures, 2 tables, 6 algorithms.

Table of Contents

  1. Introduction
  2. Order Oracles for the Assignment Discovery Problem
  3. Preliminaries
  4. The Need for Order Oracles
  5. Lower bounds for the number of discovered edges
  6. Avoiding weight calculations
  7. Order oracles
  8. Discovery Algorithms for the One-to-One Assignment Problem
  9. Order Oracles for the Vertex Sets
  10. The Greedy-Local Algorithm
  11. The Naive-Local Algorithm
  12. The $\ell$-Greedy-Local Algorithm
  13. Limitation of greedy-choice algorithms
  14. Double-Greedy Algorithm
  15. Termination of the algorithm
  16. ...and 15 more sections

Key Result

Lemma 1

Let $\alpha \geq 1$. For any input graph $G$, any $\alpha$-approximate matching discovery algorithm $\mathcal{A}$ must include in its output matching all the edges of $G$ whose weight are never inspected by $\mathcal{A}$.

Figures (11)

  • Figure 1: Examples of matchings: (a) Optimal with weight $23$, (b) Greedy with weight $17$, (c) Greedy-Local (Alg. \ref{['alg:matching1']}) with weight $16$, (d) Naive-Local (Alg. \ref{['alg:matching2']}) with weight $19$; the $1$-Greedy-Local (Alg. \ref{['alg:matching3']}) algorithm outputs the matching (a) as well as the $1$-Double-Greedy-Local (Alg. \ref{['alg:double_greedy']}). Here, the strong and weak ordering assumptions hold with $\beta = 7/3$, $\gamma = 8$, $\beta_1 = 0$, $\gamma_1=3$ and $\gamma_2=0$.
  • Figure 2: Example for Alg. \ref{['alg:matching1']}.
  • Figure 3: Example for Alg. \ref{['alg:matching2']}.
  • Figure 4: Example for Alg. \ref{['alg:matching3']}.
  • Figure 5: Example of execution for Alg. \ref{['alg:double_greedy']} using orders $\sigma_P = p_1, p_2, p_3$, $\sigma_C = c_1, c_2, c_3, c_4$ and $\ell = 1$: (a) Ordered input; (b) Constructed greedy path starting from $p_1$ with forward edges as plain lines, non-selected edges (because not local maximum) as dotted and backward edges as dashed; (c) Selected edges as optimal matching over the greedy path. Alg. \ref{['alg:double_greedy']} does not run another greedy path procedure as all nodes in $P$ are then made unavailable and outputs $M=\{(p_1,c_2),(p_3,c_4),(p_2,c_3)\}$ with total weight $w(M) = 23$.
  • ...and 6 more figures

Theorems & Definitions (47)

  • Definition 1
  • Lemma 1
  • proof
  • Lemma 2
  • proof
  • Corollary 1
  • Proposition 3
  • proof
  • Proposition 4
  • proof
  • ...and 37 more