Combinatorial algorithms
This presentation is the property of its rightful owner.
Sponsored Links
1 / 98

Combinatorial Algorithms PowerPoint PPT Presentation


  • 85 Views
  • Uploaded on
  • Presentation posted in: General

Combinatorial Algorithms. (Algorithms in Bipartite  Graphs). Outline. Introduction Algorithms in unweighted bipartite graph ( Yehong & Gordon) Maximum matching A simple algorithm Hopcroft -Karp algorithm Stable marriage problem (Wang wei ) Gale–Shapley algorithm

Download Presentation

Combinatorial Algorithms

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Combinatorial algorithms

Combinatorial Algorithms

(Algorithms in Bipartite Graphs)


Combinatorial algorithms

Outline

  • Introduction

  • Algorithms in unweighted bipartite graph (Yehong & Gordon)

    • Maximum matching

      • A simple algorithm

      • Hopcroft-Karp algorithm

  • Stable marriage problem (Wang wei)

    • Gale–Shapley algorithm

  • Algorithms in weighted bipartite graph (Wang Sheng & Jinyang)

    • Assignment problem

      • Hungarian method & Kuhn-Munkres algorithm

  • Q&A


  • Combinatorial algorithms

    Introduction

    • Definition

      • A graph G = (V, E) is bipartiteif there exists partition V = X ∪ Y with X ∩ Y = ∅ and E ⊆ X × Y.

    • Bipartite Graph types

      • Unweighted

      • Weighted

        • For every edge e ∈ E , there is a

          weight w(e) .


    Combinatorial algorithms

    Introduction

    • Example:

      • There are a set of boys and a set of girls.

      • Each boy only likes girls and each girl only likes boys.

      • A common friend wants to match each boy with a girl such that the boy and girl are both happy – but they both will only be happy if the boy likes the girl and the girl likes the boy.

      • Is it possible for every situation?

    We can use a bipartite graph to model this problem


    Combinatorial algorithms

    Introduction

    • Problem

      • Testing bipartiteness

      • Matching

        • Maximum matching problem

        • Perfect matching problem

        • Stable marriage problem

        • Maximum weight matching problem


    Maximum matching

    Maximum matching

    Yehong


    Combinatorial algorithms

    Maximum matching

    • Definition

      • Matching

        • A Matching is a subset M ⊆ E such that ∀v ∈ V at most one edge in M is incident upon v

    • Maximum matching

      • A Maximum Matching is matching M such that everyother matching M′ satisfies |M′| ≤ |M|.

      • Unweighted graph: |M|= the number of edges

      • Weighted graph: |M|=

    • Perfect Matching

      • A matching which matches all vertices of the graph


    Combinatorial algorithms

    Maximum matching

    free

    matched

    A Matching

    Not a Matching

    A Maximum Matching

    (not perfect)

    • Definition

      • We say that a vertex is matched if it is incident to some edge in M.

      • Otherwise, the vertex is free


    Combinatorial algorithms

    Maximum matching

    • Alternating paths

    • ( Y1, X2, Y2, X4 )

    • Augmenting Path

    • (Y1, X2, Y2, X4, Y4, X5)

    • Definition

      • Alternating Paths

        • A path is alternating if its edges alternate between Mand E − M.

      • Augmenting Paths

        • An alternating path is augmenting if both endpoints are free

      • Alternating Tree

        • A tree rooted at some free vertex v in which every path is an alternating path.


    Combinatorial algorithms

    Maximum matching

    • Property of Augmenting Paths

      • Replacing the M edges by the E − M ones increments size of the matching

    (Path: Y1, X2, Y2, X4, Y4, X5)

    Berge's Theorem: A matching M is maximum iff it has no augmenting path (Proof: Lec01 Page 3)


    Combinatorial algorithms

    Y1

    X1

    Y2

    X2

    Y3

    Maximum matching

    X3

    Y4

    • A simple algorithm


    Combinatorial algorithms

    Y1

    Y1

    Y1

    X1

    X1

    X1

    Y2

    Y2

    Y2

    X2

    X2

    X2

    Y3

    Y3

    Y3

    Maximum matching

    X3

    X3

    X3

    Y4

    Y4

    Y4

    • A simple algorithm


    Combinatorial algorithms

    Y1

    Y1

    Y1

    Y1

    X1

    X1

    X1

    X1

    Y2

    Y2

    Y2

    Y2

    X2

    X2

    X2

    X2

    Y3

    Y3

    Y3

    Y3

    Maximum matching

    X3

    X3

    X3

    X3

    Y4

    Y4

    Y4

    Y4

    • A simple algorithm


    Combinatorial algorithms

    Y1

    Y1

    Y1

    X1

    X1

    X1

    Y2

    Y2

    Y2

    X2

    X2

    X2

    Y3

    Y3

    Y3

    Maximum matching

    X3

    X3

    X3

    Y4

    Y4

    Y4

    • A simple algorithm


    Combinatorial algorithms

    Y1

    X1

    Y2

    X2

    Y3

    Maximum matching

    X3

    Y4

    • A simple algorithm

    • Commonly search algorithm (BFS, DFS) O(E)

    • At most V times

    • Complexity: O(VE)


    Hopcroft karp algorithm

    Hopcroft-Karp Algorithm

    An algorithm to find the maximum matching given a bipartite graphGordon


    Combinatorial algorithms

    Introduction

    • The Hopcroft-Karp algorithm was published in 1973

    • It is a matching algorithm that finds a maximum matching in bipartite graphs

    • The main idea is to augment along a set of vertex-disjoint shortest augment paths simulatenously

    • The complexity is O(√|V||E|)

    • In this section, some Theorems and Lemmas from graph theory will be stated without showing the proof.


    Combinatorial algorithms

    Definition

    • We let the set A⊕ B denote the symmetric difference of the set

    • A ⊕ B = (A ∪ B) – (A ∩ B)

    • A maximal set of vertex-disjoint minimum length augmenting path is defined as follows :

      • It is a set of augmenting path

      • No two path share a same vertex

      • If the minimum length augmenting path is of length k, then all paths in S are of length k

      • If p is an augmenting path not in S, then p shares a vertex with some path p’ in S


    Combinatorial algorithms

    Algorithm

    The algorithm of Hopcroftand Kraft is as follows :

    Given a graph G = (X ∪ Y),E)

    1) Let M = {} ,

    2) Find S = {P1 , P2 , … Pk}

    3) While S ≠ {}

    M = M ⊕ S

    Find S

    4) Output M


    Combinatorial algorithms

    Demonstration of algorithm at some stage

    Let the dark edges represent the edges in a matching M


    Combinatorial algorithms

    Demonstration of algorithm at some stage

    Pink edges represent an augmenting path

    Deleting them


    Combinatorial algorithms

    Demonstration of algorithm at some stage

    Another augmenting path

    No more paths


    Combinatorial algorithms

    Demonstration of algorithm at some stage

    Pink edges represent the paths in maximal set S

    M ⊕ SNote the before and after


    Combinatorial algorithms

    Algorithm

    • Question : How do we know that this algorithm produces the result that we want ?

    • Theorem 1 (Berge) :A matching M is maximum if and only if there is no augmenting path with respect to M

    • This theorem guarantees the correctness of the algorithm

    • We will now prove that the complexity of the algorithm is O(√|V||E|)


    Combinatorial algorithms

    Lemma 2 : A maximal set S of vertex-disjoint minimum length augmenting paths can be found in O(|E|) time

    Proof : Let G = (U ∪ V,E) be the graph that we are working on and M be a matching

    • First , we construct a “tree-like/directed acyclic graph” graph given G

    • We start with all the free vertices in U at level 0


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • Starting at level 2k (even) , the vertices at level 2k+1 are obtained by following free edges from edges at level 2k

    • Starting at level 2k+1 (odd) , the level at 2k+2 are obtained by following matched edges from vertices at level 2k+1

    • Note that the even levels contain vertices from U and odd levels from V

    U

    Recall the earlier example : There are 3 levels here

    V


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • We continue building the tree until all vertices have been visited or until a free vertex is encountered (say t)

    • Note that in the latter case, the free vertices are encountered at V

    • Complexity of this portion of building the “tree” is linear to the size of the edges ( similar to BFS)


    Combinatorial algorithms

    Continuation of proof of lemma 2

    Dashed line represent edges while the normal lines represent edges in the matching M

    Example :

    Free-vertex

    0

    1

    2

    3


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • Now we find a maximal set S of vertex disjoint paths in this “tree” that we constructed

    • We assign a counter to all vertices after level 0

    • This counter represents the number of edges entering the vertex previous level (think of it like an indegree)

    • Starting at a free vertex v at level t, we trace a path until we reach a free vertex u at level 0


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • This path is an augmenting path and we add it into S

    • After which , we add the vertices in this path into a deletion queue

    • As long as the deletion queue is non empty, we delete the vertex in the queue and from the constructed “tree”

    • This includes all the edges incident onto it

    Recall the earlier example


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • Whenever an edge is deleted , the counter associated with its right endpoint are all decremented

    • If the counter becomes 0, put the vertex into the deletion queue (there can be no augmenting path from this vertex)

    • After emptying the deletion queue, if there are still free vertex at level t , it means that an augmenting path must still exist


    Combinatorial algorithms

    Continuation of proof of lemma 2

    • We continue until there are no more free vertex at level t

    • This entire process takes linear time , since it is proportional to the number of edges deleted

    • Therefore this part takes O(|E|)

    • Total time complexity for both parts is O(|E|)


    Combinatorial algorithms

    Continuation of proof of lemma 2

    Example :

    Consider the path : v6 u6 v5 u1

    Deletion Queue

    Counter of v1 decreases by 1


    Combinatorial algorithms

    Continuation of proof of lemma 2

    Example :

    0

    0

    0

    Now consider the path : v3 u3 v1 u2

    Deletion Queue


    Combinatorial algorithms

    Theorems and Lemmas cited without proof

    • Lemma 3 : Let M* be a maximum matching, and let M be any matching in G. If the length of the shortest augmenting path with respect to M is k, then |M*| - |M| ≤ (|V|/k)

    • Lemma 4 : Let k be the length of the shortest augmenting path with respect to M and let S be a maximal set of shortest disjoint augmenting paths with respect to M, then the length of the shortest augmenting path with respect to M⊕S is larger than k


    Combinatorial algorithms

    Theorem 5: The Hopcroft-Karp algorithm finds a maximum matching in a bipartite graph in O(√|V||E|) time

    Proof :

    • Now we run the algorithm for √|V| and let M be matching after running those rounds

    • Lemma 4 implies that we have that in each phrase of the algorithm, the length of the shortest augmenting path increases by at least 1

    • Therefore the size of the shortest augmenting path must be at least √|V|


    Combinatorial algorithms

    Continuation of proof of Theorem 5

    • Now from Lemma 3, we have that |M*| - |M| ≤ (|V|/√|V|) = √|V|

    • In each phrase , we increase the size of the matching by at least 1, so therefore , at most √|V| more phrases needed

    • Therefore at most 2 √|V| phrases are needed for this entire algorithm.

    • Therefore with lemma 2, the time complexity of the algorithm is O(√|V| |E|)


    Stable marriage problem

    Stable Marriage Problem

    Wang Wei


    Combinatorial algorithms

    Terminology

    • Problem definition:

      • Given n men and n women, each person has a preference list for all members of the opposite sex; Find a one-to-one match M.

      • If m(a man) and w (a woman) are matched in M, then m is the partner of w, and vice verse.

    • Blocking pair in a match M: (m, w), m prefers w than his partner in M, and w prefers mthan her partner.

    • Stable match: no blocking pair exist.


    Combinatorial algorithms

    Stability-checking algorithm

    • For each man, try to find a woman, with whom they form a blocking pair; if no such woman exist, then the match is stable.

    • Complexity: O(n2)

    • Example:http://mathsite.math.berkeley.edu/smp/smp.html


    Combinatorial algorithms

    Basic Gale-Shapley algorithm

    • For man, propose to every women on his preference list until get engaged;

    • For woman, wait for proposal, accept if free or prefer the proposer than current partner/fiance; otherwise reject the proposal;

    • Complexity: O(n2)


    Combinatorial algorithms

    Theorem 1.

    • For any given instance of the stable marriage problem, the Gale-Shapley algorithm terminates, and, on termination, the engaged pairs constitute a stable matching.

    • Termination:

    • Stability: if m prefers w than his partner , then w must have rejected m, i.e., w prefers her partner to m. (m,w) cannot be a block pairno block pair exists.

    If GS not terminate, then at least one man is free

    • To reject a man, the woman must be engaged

    • He must be rejected by all women

    • Once a woman is engaged, she will never be free

    • All women are engaged

    • All men are engaged


    Combinatorial algorithms

    • Theorem 2: All possible executions of the Gale-Shapley algorithm(with the men as the proposers) yield the same stable matching, in which, man has the best partner he can have in any stable matching.

    • Theorem 3: In the man-optimal stable matching, each woman has the worst partner that she can have in any stable matching.


    The hungarian method

    The Hungarian Method

    Jinyang


    Combinatorial algorithms

    Assignment Problem

    • Suppose we have n resources to which we want to assign to n tasks on a one-to-one basis. Suppose we also know the cost(gain) of assigning a given resource to a given task. We wish to find an optimal assignment–one which minimizes(maximizes) total cost(gain).

    • Min-Cost or Max-Weight Perfect Matching in Bipartite Graph.


    Combinatorial algorithms

    Example

    • Three students collaborate to finish a project. Their efficiency is different.


    Combinatorial algorithms

    Matrix Representation

    • We will formula this problem in a matrix representation. It is easier to illustrate its key idea and how it works.

    • We will explain how to implement it into algorithm and show its complexity later.

    • We will use minimum cost form of the problem. For maximum problem, we just reverse the num.


    Combinatorial algorithms

    Matrix Representation


    Combinatorial algorithms

    Difficulty


    Combinatorial algorithms

    Theorem 1

    • If a number is added to or subtracted from all of the entries of any one row or column of a cost matrix, then on optimal assignment for the resulting cost matrix is also an optimal assignment for the original cost matrix.

    • You have to choose one entry in each row or column any way. So this operation add or reduce the same number for all assignment.


    Combinatorial algorithms

    Assignment Problem


    Combinatorial algorithms

    Theorem 2

    • When there exist a assignment has a zero cost in a non-negative matrix. This assignment is an optimal assignment.


    Combinatorial algorithms

    Hungarian Method

    • The key idea of Hungarian Method is to transform the original matrix to a non-negative matrix which have a zero assignment by add or subtract operation in each row and column.

    • There will be some slight difference in different implementation.


    Combinatorial algorithms

    Hungarian Method

    • Step 1: Subtract the smallest entry in each row from all the entries of its row.

    • Step 2: Subtract the smallest entry in each column from all the entries of its column.

    • This two step is not necessary. But it can reduce the number of iterations later. The only requirement is that it comes to a non-negative matrix.


    Combinatorial algorithms

    Hungarian Method

    • Step 3: Draw lines through appropriate rows and columns so that all the zero entries of the cost matrix are covered and the minimum number of such lines is used.

    • Step 4: If the minimum number of covering lines is n, an optimal assignment of zeros is possible and we are finished. Else continue step 5.

    • Step 5: Determine the smallest entry not covered by any line. Subtract this entry from each uncovered row, and then add it to each covered column. Return to Step 3.


    Combinatorial algorithms

    Example 1


    Combinatorial algorithms

    Example 2

    • Less than 3 lines.


    Combinatorial algorithms

    Example 2

    • Step 5:


    Combinatorial algorithms

    Example 2

    • Return to step 3:

    • Number of lines equals to 3. Finished.


    Combinatorial algorithms

    How to Draw Lines

    • The lines is a minimum dominating set of all zero point.

    • Transform the solution of maximum matching to minimum dominating set.


    Combinatorial algorithms

    How to Draw Lines


    Combinatorial algorithms

    How to Draw Lines

    • Find a maximum assignment(maximum match).


    Combinatorial algorithms

    How to Draw Lines

    • Find a maximum assignment(maximum match).

    • Mark all rows having no assignments .


    Combinatorial algorithms

    How to Draw Lines

    • Find a maximum assignment(maximum match).

    • Mark all rows having no assignments . Then mark all columns having zeros in marked row(s).


    Combinatorial algorithms

    How to Draw Lines

    • Find a maximum assignment(maximum match).

    • Mark all rows having no assignments . Then mark all columns having zeros in marked row(s). Then mark all rows having assignments in marked columns .Repeat this until a closed loop is obtained.


    Combinatorial algorithms

    How to Draw Lines

    • Find a maximum assignment(maximum match).

    • Mark all rows having no assignments . Then mark all columns having zeros in marked row(s). Then mark all rows having assignments in marked columns .Repeat this until a closed loop is obtained.

    • Then draw lines through all marked columns and unmarked rows.


    Combinatorial algorithms

    Why Always Stop?

    • There are at most n-1 lines. Suppose there are m row lines and k column lines. The smallest entry is x.

    • We subtract from the sum of all entries of the matrix. And then add . The sum reduces at least.

    • The sum value becomes smaller and smaller in each iteration. (complexity will be shown in KM algorithm)


    Kuhn munkres algorithm the polynomial hungarian method

    Kuhn-Munkres Algorithmthe Polynomial Hungarian Method

    Wang Sheng


    Combinatorial algorithms

    Evolvement of Hungarian Method

    • 1955, Harold Kuhn

      • Hungarian method was published and was largely based on the earlier works of two Hungarian mathematicians

    • 1957, James Munkres

      • Munkres observed it is polynomial in O(n4) and since then the algorithm was also known as Kuhn-Munkres algorithm

    • 1960, Edmonds and Karp

      • The KM algorithm was modified to achieve an O(n3) running time


    Combinatorial algorithms

    Introduction to KM Algorithm

    • Basic Hungarian method

      • Consider assignment problem in terms of matrix

      • Idea: add/subtract X from all entries of a row/column

      • Goal: choose 0s from nonnegative matrix

      • Easy to understand

    • Kuhn-Munkres algorithm

      • Consider assignment problem in terms of bipartite graph

      • Easy to analysis and implement

    • Our Goal

      • Introduce KM and show both of them are equivalent


    Combinatorial algorithms

    Restate Assignment Problem

    • Matrix vs. Bipartite graph

      • For each entry Ci,jin matrix, there is an edge in bipartite graph from Xi to Yj with weight equal to Ci,j

    • In order to be consistent with theorems introduced in the algorithm we consider max-weight matching

    Y1

    Y2

    Y3

    3

    3

    3

    1

    2

    2

    2

    1

    0

    X1

    X2

    X3


    Combinatorial algorithms

    Definitions

    • Feasible labeling L

      • A vertex labeling is a function L : V → R

      • A feasible labeling is one such that L(x)+L(y) ≥ w(x, y), ∀x ∈ X, y ∈ Y

    • Equality Graphs

      • Equality Graph is G = (V,EL) whereEL= {(x, y) : L(x)+L(y) = w(x, y)}

    2

    1

    2

    3

    3

    3

    1

    2

    2

    2

    1

    0

    1

    1

    1


    Combinatorial algorithms

    Kuhn-Munkres Theorem

    • If L is feasible and M is a perfect matching in EL then M is a max-weight matching

      • each node is covered exactly once and L(x)+L(y) ≥ w(x, y)therefore the upper-bound of the weight is the sum of labels

    • Power of the theorem

      • Transform problem from weightedmatching to un-weighted perfectmatching

    1

    1

    1


    Combinatorial algorithms

    Inspiration from KM Theorem

    • Key idea

      • find a good feasible labeling that remains enough edges in equality graph to ensure perfect matching can be done

    • Algorithm proposal

      • Start with any feasible labeling L and some matching M in EL

      • While M is not perfect, repeat:Find an augmenting path in EL to increase the size of Morif no path exists, improve L to L’ such that EL⊂EL’


    Combinatorial algorithms

    Finding an Initial Feasible Labeling

    • Simplest assignment

      • Maximize L(x) while Minimize L(y)∀y ∈ Y, L(y) = 0∀x ∈ X, L(x) = max{w(x,y)}, y ∈ Y

      • It is obvious that∀x ∈ X, y ∈ Y, w(x, y) ≤L(x)+L(y)

    Y1 0

    Y2 0

    Y3 0

    1

    1

    6

    8

    6

    4

    X1 6

    X2 8

    X3 4


    Combinatorial algorithms

    Improving Labeling

    • Neighbor of u ∈ V and S ⊆ V

      • NL(u) = { v : (u,v) ∈ EL }

      • NL(S) = ∪u ∈ S NL(u)

    • Lemma

      • Let S ⊆ X and T = NL(S) ≠ Y.

      • Set αL = min { L(x) + L(y) – w(x,y) }, x ∈ S, y ∉ T

      • Update the labels(1) if v ∈ SL’(v) = L(v) - αL(2) if v ∈ TL’(v) = L(v) + αL (3) otherwiseL’(v) = L(v)

      • Then L’ is a feasible labeling


    Combinatorial algorithms

    Equivalence of Graph and Matrix

    • αL = min { L(x) + L(y) – w(x,y) }, x ∈ S, y ∉ T

      • Consider a matrix C with –w(x,y) as its elements

      • For row x ∈ X / columny ∈ Y, addL(x)/ L(y)toeachelement

      • Problemisequivalenttosolvethe min-costassignment in C

      • EdgewithL(x) + L(y) = w(x,y) is the 0 element in matrix C

    • (1) if v ∈ S, L’(v) = L(v) - αL(2) if v ∈ T, L’(v) = L(v) + αL

      • S : set of uncovered rowsT : set of covered columns

      • αL : the smallest entry not covered by any line

      • Subtract this entry from each uncovered row, and then add it to each covered column


    Combinatorial algorithms

    Effectiveness of Label Update

    • Edges in EL’(1) if v ∈ SL’(v) = L(v) - αL(2) if v ∈ TL’(v) = L(v) + αL (3) otherwiseL’(v) = L(v)

      • If (x,y) ∈ ELforx ∈ S,y ∈ T then(x,y) ∈ EL’

      • If (x,y) ∈ ELforx ∉ S,y ∉ T then(x,y) ∈ EL’

      • There is some edge (x,y) ∈ EL’ forx ∈ S,y ∉ T

    • With good choice of S, we can guarantee there are more edges in new Equality Graph


    Combinatorial algorithms

    Kuhn-Munkres Algorithm

    • Generate initial labeling L and matching M in EL

    • If M is perfect, terminate.Otherwise pick free vertex u ∈ X.Set S = {u}, T = {}.

    • If NL(S) = T, update labels(forcing NL(S) ≠ T)αL = min { L(x) + L(y) – w(x,y) }, x ∈ S, y ∉ T(1) if v ∈ SL’(v) = L(v) - αL(2) if v ∈ TL’(v) = L(v) + αL (3) otherwiseL’(v) = L(v)

    • IfNL(S) ≠ T, pick y ∈ NL(S) – T.If y is free, augmenting u-y and go to 2.If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. Go to 3.


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1

    Y1

    Y2

    Y2

    Y3

    Y3

    1

    6

    8

    1

    6

    4

    X1

    X1

    X2

    X2

    X3

    X3

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    1

    6

    8

    1

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    1

    6

    8

    1

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    1

    6

    8

    1

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    S = {X1}

    1

    6

    8

    1

    T = {}

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    S = {X1}

    1

    6

    8

    1

    T = {}

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    S = {X1}

    1

    6

    8

    1

    T = {}

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 0

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 6

    X1

    X2 8

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2 6

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2 6

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2 6

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2 6

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2 6

    X2

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Example

    max-weight is 16

    Generate initial labeling and matching

    Pick a free vertex, set S={u} T={}; otherwise stop

    If NL(S) = T, update labels (force NL(S) ≠ T)

    If NL(S) ≠ T, pick y to be NL(S) – T

    If y is free, augment u – y, go to step 2If y is matched to z, S = S ∪ {z}, T = T ∪ {y}. go to step 3

    Y1 0

    Y1

    Y2 2

    Y2

    Y3 0

    Y3

    S = {X1,X2}

    1

    6

    8

    1

    T = {Y2}

    6

    4

    X1 4

    X1

    X2

    X2 6

    X3

    X3 4

    Equality Graph + Matching

    Original Graph


    Combinatorial algorithms

    Complexity

    • In each phase of algorithm, |M| increases by 1, so there are at most V phases.

    • ∀y ∉ T keep track of slacky = min{L(x)+L(y)-w(x,y)}

    • In each phase

      • Initializing all slacks. O(V)

      • When a vertex moves into S, all slacks need update. O(V)Only |V| vertices can be moved into S. O(V2)

      • When updating labels, αL = min(slacky). O(V)After getting αL, must update slacky = slacky-αL. O(V) αL can be calculated |V| times per phase. O(V2)

      • Total time per phase is O(V2)

    • Total running time is O(V3)


    Combinatorial algorithms

    Q & A


    References

    References

    Maximum matching / Hopcroft-Karp Algorithm :

    • http://en.wikipedia.org/wiki/Matching_(graph_theory)

    • http://www.cs.dartmouth.edu/~ac/Teach/CS105-Winter05/Notes/kavathekar-scribe.pdf

    • http://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm

    • http://www2.informatik.huberlin.de/alkox/lehre/lvss12/ga/notes/HK.pdf

    • http://www.dis.uniroma1.it/~leon/tcs/lecture2.pdf


    References1

    References

    Stable Matching Problem :

    • http://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15251-f10/Site/Materials/Lectures/Lecture21/lecture21.pdf

      Hungarian Method & Kuhn Munkres Algorithm

    • http://www.cse.ust.hk/~golin/COMP572/Notes/Matching.pdf

    • http://www.math.harvard.edu/archive/20_spring_05/handouts/assignment_overheads.pdf

    • http://en.wikipedia.org/wiki/Hungarian_algorithm

    • http://en.wikipedia.org/wiki/Dominating_set


  • Login