The selfish-edges Shortest-Path problem. The selfish-edges SP problem Input: an undirected graph G=(V,E) such that each edge is owned by a distinct selfish.

Slides:



Advertisements
Similar presentations
Single Source Shortest Paths
Advertisements

Algorithmic Mechanism Design: an Introduction VCG-mechanisms for some basic network optimization problems: The Minimum Spanning Tree problem Guido Proietti.
Priority Queues  MakeQueuecreate new empty queue  Insert(Q,k,p)insert key k with priority p  Delete(Q,k)delete key k (given a pointer)  DeleteMin(Q)delete.
Advanced Data structure
The Greedy Approach Chapter 8. The Greedy Approach It’s a design technique for solving optimization problems Based on finding optimal local solutions.
October 31, Algorithms and Data Structures Lecture XIII Simonas Šaltenis Nykredit Center for Database Research Aalborg University
November 14, Algorithms and Data Structures Lecture XIII Simonas Šaltenis Aalborg University
1 Theory I Algorithm Design and Analysis (10 - Shortest paths in graphs) T. Lauer.
By Amber McKenzie and Laura Boccanfuso. Dijkstra’s Algorithm Question: How do you know that Dijkstra’s algorithm finds the shortest path and is optimal.
1 Greedy 2 Jose Rolim University of Geneva. Algorithmique Greedy 2Jose Rolim2 Examples Greedy  Minimum Spanning Trees  Shortest Paths Dijkstra.
Jim Anderson Comp 122, Fall 2003 Single-source SPs - 1 Chapter 24: Single-Source Shortest Paths Given: A single source vertex in a weighted, directed graph.
Shortest Paths Definitions Single Source Algorithms –Bellman Ford –DAG shortest path algorithm –Dijkstra All Pairs Algorithms –Using Single Source Algorithms.
SECOND PART: Algorithmic Mechanism Design. Mechanism Design MD is a subfield of economic theory It has a engineering perspective Designs economic mechanisms.
1 8-ShortestPaths Shortest Paths in a Graph Fundamental Algorithms.
Greedy Algorithms Reading Material: Chapter 8 (Except Section 8.5)
The selfish-edges Minimum Spanning Tree (MST) problem.
A Truthful 2-approximation Mechanism for the Steiner Tree Problem.
Shortest Paths Definitions Single Source Algorithms
Vickery Prices and Shortest Paths: What is an edge worth? Authors: John Hershberger and Subhash Suri Presenter: Ali Ebnenasir.
Vickrey Prices and Shortest Paths What is an Edge Worth? By John Hershberger and Subhash Suri Carlos Esparza and Devin Low 3/5/02.
Fibonacci Heaps. Single Source All Destinations Shortest Paths
Greedy Algorithms Like dynamic programming algorithms, greedy algorithms are usually designed to solve optimization problems Unlike dynamic programming.
1 CSE 417: Algorithms and Computational Complexity Winter 2001 Lecture 11 Instructor: Paul Beame.
Dijkstra’s Algorithm Slide Courtesy: Uwash, UT 1.
Princeton University COS 423 Theory of Algorithms Spring 2002 Kevin Wayne Fibonacci Heaps These lecture slides are adapted from CLRS, Chapter 20.
TECH Computer Science Graph Optimization Problems and Greedy Algorithms Greedy Algorithms  // Make the best choice now! Optimization Problems  Minimizing.
Theory of Computing Lecture 7 MAS 714 Hartmut Klauck.
Dijkstra's algorithm.
1 Binomial heaps, Fibonacci heaps, and applications.
9/10/10 A. Smith; based on slides by E. Demaine, C. Leiserson, S. Raskhodnikova, K. Wayne Adam Smith Algorithm Design and Analysis L ECTURE 8 Greedy Graph.
Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Cpt S 223 – Advanced Data Structures Graph Algorithms Shortest-Path.
Jim Anderson Comp 122, Fall 2003 Single-source SPs - 1 Chapter 24: Single-Source Shortest Paths Given: A single source vertex in a weighted, directed graph.
MST Many of the slides are from Prof. Plaisted’s resources at University of North Carolina at Chapel Hill.
 2004 SDU Lecture 7- Minimum Spanning Tree-- Extension 1.Properties of Minimum Spanning Tree 2.Secondary Minimum Spanning Tree 3.Bottleneck.
All-Pairs Shortest Paths & Essential Subgraph 01/25/2005 Jinil Han.
Chapter 24: Single-Source Shortest Paths Given: A single source vertex in a weighted, directed graph. Want to compute a shortest path for each possible.
The single-source shortest path problem (SSSP) input: a graph G = (V, E) with edge weights, and a specific source node s. goal: find a minimum weight (shortest)
The Minimum Spanning Tree (MST) problem in graphs with selfish edges.
Partial Soluti on and Entropy Tadao Takaoka Department of Computer Science University of Canterbury Christchurch, New Zealand.
The Shortest Path problem in graphs with selfish edges.
The Shortest-Path problem in graphs with selfish-edges.
En tropy as Computational Complexity Computer Science Replugged Tadao Takaoka Department of Computer Science University of Canterbury Christchurch, New.
Lecture 13 Algorithm Analysis
1 EE5900 Advanced Embedded System For Smart Infrastructure Static Scheduling.
One-parameter mechanisms, with an application to the SPT problem.
15.082J & 6.855J & ESD.78J September 30, 2010 The Label Correcting Algorithm.
Theory of Computing Lecture 12 MAS 714 Hartmut Klauck.
Single Source Shortest Paths Chapter 24 CSc 4520/6520 Fall 2013 Slides adapted from George Bebis, University of Reno, Nevada.
Local Connection Game. Introduction Introduced in [FLMPS,PODC’03] A LCG is a game that models the creation of networks two competing issues: players want.
Network Formation Games. NFGs model distinct ways in which selfish agents might create and evaluate networks We’ll see two models: Global Connection Game.
CS38 Introduction to Algorithms Lecture 3 April 8, 2014.
Proof of correctness of Dijkstra’s algorithm: Basically, we need to prove two claims. (1)Let S be the set of vertices for which the shortest path from.
Network Formation Games. NFGs model distinct ways in which selfish agents might create and evaluate networks We’ll see two models: Global Connection Game.
Binomial heaps, Fibonacci heaps, and applications
Lectures on Network Flows
Algorithms and Data Structures Lecture XIII
Greedy Algorithms / Minimum Spanning Tree Yin Tat Lee
Enumerating Distances Using Spanners of Bounded Degree
3.5 Minimum Cuts in Undirected Graphs
Data Structures – LECTURE 13 Minumum spanning trees
Algorithms and Data Structures Lecture XIII
Lecture 13 Algorithm Analysis
Lecture 13 Algorithm Analysis
Lecture 13 Algorithm Analysis
Lecture 13 Algorithm Analysis
The Shortest-Path problem in graphs with selfish-edges
Autumn 2016 Lecture 10 Minimum Spanning Trees
CSE 417: Algorithms and Computational Complexity
Binomial heaps, Fibonacci heaps, and applications
Data Structures and Algorithm Analysis Lecture 8
Presentation transcript:

The selfish-edges Shortest-Path problem

The selfish-edges SP problem Input: an undirected graph G=(V,E) such that each edge is owned by a distinct selfish agent, a source node s and a destination node z; we assume that agent’s private type is the positive cost (length) of the edge, and his valuation function is equal to his type if edge is selected in the solution, and 0 otherwise. SCF: a (true) shortest path in G between s and z.

Notation and assumptions n=|V|, m=|E| d G (s,z): distance in G=(V,E,r) between s ans z (sum of reported costs of edges on a shortest path P G (s,z)) Nodes s and z are 2-edge-connected in G, i.e., there exists in G at least 2 edge disjoint paths between s and z  for any edge of P G (s,z) removed from the graph there exist at least one replacement path in G-e between s and z (this will bound the problem, since otherwise a bridge-edge might have an unbounded marginal utility)

VCG mechanism The problem is utilitarian (indeed, the cost of a solution is given by the sum of the valuations of the selected edges)  VCG-mechanism M= : g(r): computes P G (s,z) in G=(V,E,r) p e : for each e  E: p e =  j≠e v j (r j,x(r - e )) -  j≠e v j (r j,x), namely d G-e (s,z)-(d G (s,z)-r e ) if e  P G (s,t) 0 otherwise  For each e  P G (s,z), we have to compute d G-e (s,z), namely the length of a shortest path in G-e =(V,E\{e},r -e ) between s and z. pe=pe= {

The best replacement path s z e P G-e (s,z) P G (s,z) Remark: p e  r e, since d G-e (s,z)  d G (s,z)

A trivial but costly implementation Step 1: First of all, apply Dijkstra to compute P G (s,z)  this costs O(m + n logn) time by using Fibonacci heaps. Step 2: Then,  e  P G (s,z) apply Dijkstra in G-e to compute P G-e (s,z)  we spend O(m + n logn) time for each of the O(n) edges in P G (s,z), i.e., O(mn + n 2 logn) time  Overall complexity: O(mn + n 2 logn) time We will see an efficient solution costing O(m + n logn) time

Notation S G (s), S G (z): single-source shortest paths trees rooted at s and z M s (e): set of nodes in S G (s) not descending from edge e (i.e., the set of nodes whose shortest path from s does not use e) N s (e)=V/M s (e) M z (e), N z (e) defined analogously

A picture s u v z e Ms(e)Ms(e) Ns(e)Ns(e) S G (s)

Crossing edges (M s (e),N s (e)) is a cut in G C s (e)={(x,y)  E\{e}: x  M s (e), y  N s (e)} edges “belonging” to the cut: crossing edges

Crossing edges s u v z e Ms(e)Ms(e) Ns(e)Ns(e) S G (s) Cs(e)Cs(e)

What about P G-e (s,z)? Trivial: it does not use e It must cross the cut C s (e) It is shortest among all the paths between s and z not using e Its length is: where w(f) denotes the cost declared for f. d G-e (s,z)= min {d G-e (s,x)+w(f)+d G-e (y,z)} f=(x,y)  C s (e)

The path P G-e (s,z) s u v z e x y d G-e (s,z)= min {d G-e (s,x)+w(f)+d G-e (y,z)} f=(x,y)  C s (e)

How to compute d G-e (s,z) Let f=(x,y)  C s (e); we will show that d G-e (s,x)+w(f)+d G-e (y,z)=d G (s,x)+w(f)+d G (y,z) Remark: d G-e (s,x)=d G (s,x), since x  M s (e) Lemma: Let f=(x,y)  C s (e) be a crossing edge (x  M s (e)). Then y  M z (e) (from which it follows that d G-e (y,z)=d G (y,z)).

A simple lemma Proof (by contr.) Let y  M z (e), then y  N z (e). Hence, y is a descendant of u in S G (z), and P G (z,y) uses e. But P G (v,y) is a subpath of P G (z,y), and then: d G (v,y)=w(e) + d G (u,y) > d G (u,y). But y  N s (e), then P G (s,y) uses e. But P G (u,y) is a subpath of P G (s,y), an then: d G (u,y)=w(e) + d G (v,y) > d G (v,y).

A picture s z N s (e)  M z (e) Ms(e)Ms(e)

Computing best replacement paths Given S G (s) and S G (z), in O(1) time we compute: k(f):= d G-e (s,x) + w(f) + d G-e (y,z) d G (s,x) given by S G (s) Remark: k(f) is the length of a shortest path between s and z passing through f d G (y,z) given by S G (z)

A corresponding algorithm Step 1: Compute S G (s) and S G (z) Step 2:  e  P G (s,z) check all the crossing edges in C s (e), and take the minimum w.r.t. k(). Time complexity Step 1: O(m + n logn) time Step 2: O(m) crossing edges for each of the O(n) edges on P G (s,z): total of O(mn) time  Overall complexity: O(mn) time Improves on O(mn + n 2 logn) if m=o(n logn)

A more efficient solution: the Malik, Mittal and Gupta algorithm (1989) MMG have solved in O(m+n log n) time the following related problem: given a SP P G (s,z), what is its most vital edge, namely an edge whose removal induces the worst (i.e., longest) best replacement path between s and z? Their approach computes efficiently all the best replacement paths between s and z… …but this is exactly what we are looking for in our VCG-mechanism!

The MMG algorithm at work Let e 1, e 2,…, e q be the edges of P G (s,z) from s to z, in this order. At Step i, we maintain in a heap H the set of nodes N s (e i ) (initially H=V) Let us call active the nodes in H. With each node y  H, we associate a key k(y) and a corresponding crossing edge, as follows: k(y)= min {d G (s,x)+w(x,y)+d G (y,z)}  k(y) is the length of a SP in G-e i from s to z passing through the active node y (x,y)  E, x  M s (e i )

The MMG algorithm at work (2) Initially, H =V, and k(y)=+  for any y  V Consider e 1, e 2,…, e q one after the other. When edge e i is considered, modify H as follows: Remove from H all the nodes in W s (e i )=N s (e i-1 )\N s (e i ) Consider all the edges (x,y) s.t. x  W s (e i ) and y  H, and compute k’(y)=d G (s,x)+w(x,y)+d G (y,z). If k’(y)<k(y), decrease k(y) to k’(y), and update the corresponding crossing edge to (x,y) Then, find the minimum in H w.r.t. k(), which returns the length of a best replacement path for e i (i.e., d G-e i (s,z)), along with the selected crossing edge

An example N s (e 1 ) e1e1 e2e2 e3e3 e5e5 e4e4 s z W s (e 1 )

An example (2) N s (e 2 ) e1e1 e2e2 e3e3 e5e5 e4e4 s z W s (e 2 )

Time complexity of MMG Theorem: Given a shortest path between two nodes s and z in a graph G with n vertices and m edges, all the best replacement paths between s and z can be computed in O(m + n log n) time.

Time complexity of MMG Proof: Compute S G (s) and S G (z) in O(m + n logn) time. Then, use a Fibonacci heap to maintain H, on which the following operations are executed: A single make_heap O(n) insert O(n) find_min O(n) delete O(m) decrease_key In a Fibonacci heap, the amortized cost of a delete and a delete_min is O(logn), while insert, find_min, decrease_key,make_heap cost O(1), so O(m + n logn) total time

Plugging-in the MMG algorithm into the VCG-mechanism Corollary There exists a VCG-mechanism for the selfish- edges SP problem running in O(m + n logn) time. Proof. Running time for g(): O(m + n logn) (Dijkstra). Running time of p(): O(m + n logn), by applying MMG to compute all the distances d G-e (s,z).