Download presentation

Presentation is loading. Please wait.

1
**Joint work with Rob Irving**

The Stable Roommates Problem with Ties David Manlove Joint work with Rob Irving University of Glasgow Department of Computing Science Supported by: EPSRC grants GR/M13329 and GR/R84597/01 Nuffield Foundation award NUF-NAL-02 RSE/Scottish Executive Personal Research Fellowship

2
**Stable Roommates (SR): definition**

Input: 2n persons; each person ranks all 2n-1 other persons in strict order Output: a stable matching Definitions A matching is a set of n disjoint pairs of persons A blocking pair of a matching M is a pair of persons {p,q}M such that: p prefers q to his partner in M, and q prefers p to his partner in M A matching is stable if it admits no blocking pair

3
**Stable Roommates (SR): definition**

Input: 2n persons; each person ranks all 2n-1 other persons in strict order Output: a stable matching Definitions A matching is a set of n disjoint pairs of persons A blocking pair of a matching M is a pair of persons {p,q}M such that: p prefers q to his partner in M, and q prefers p to his partner in M A matching is stable if it admits no blocking pair Example SR instance I1: 1: 2: 3: 4:

4
**Stable Roommates (SR): definition**

Input: 2n persons; each person ranks all 2n-1 other persons in strict order Output: a stable matching Definitions A matching is a set of n disjoint pairs of persons A blocking pair of a matching M is a pair of persons {p,q}M such that: p prefers q to his partner in M, and q prefers p to his partner in M A matching is stable if it admits no blocking pair Example SR instance I1: 1: 2: 3: 4:

5
**Stable Roommates (SR): definition**

Input: 2n persons; each person ranks all 2n-1 other persons in strict order Output: a stable matching Definitions A matching is a set of n disjoint pairs of persons A blocking pair of a matching M is a pair of persons {p,q}M such that: p prefers q to his partner in M, and q prefers p to his partner in M A matching is stable if it admits no blocking pair Example SR instance I1: 1: 2: 3: 4: The matching is not stable as {1,3} blocks.

6
Stable matching in I1: 1: 2: 3: 4:

7
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4:

8
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4:

9
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4:

10
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4: 1: 2: 3: 4:

11
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4: 1: 2: 3: 4:

12
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4: 1: : 2: : 3: : 4: :

13
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4: 1: : 2: : 3: : 4: :

14
Stable matching in I1: 1: 2: 3: 4: Example SR instance I2: 1: 2: 3: 4: 1: : 2: : 3: : 4: : The three matchings containing the pairs {1,4}, {2,4}, {3,4} are blocked by the pairs {1,2}, {2,3}, {3,1} respectively. instance I2 has no stable matching. SR was first studied in 1962 by Gale and Shapley

15
**Stable marriage (SM) problem**

SM is a special case of SR Input: n men and n women; each person ranks all n members of the opposite sex in order Output: a stable matching Definitions: A matching is a set of n disjoint (man,woman) pairs A blocking pair of a matching M is an unmatched (man,woman) pair (m,w) such that: m prefers w to his partner in M, and w prefers m to her partner in M A matching is stable if it admits no blocking pair Every instance of SM admits a stable matching Such a matching can be found by an efficient algorithm known as the Gale/Shapley algorithm

16
Reduction from SM to SR An instance I of SM can be reduced to an instance J of SR such that set of stable matchings in I = set of stable matchings in J SM instance I: U={m1, m2,..., mn} is the set of men, and W={w1, w2,..., wn} is the set of women SR instance J: People comprise men in U and women in W mi’s list in J is his list in I together with the men in U\{mi} appended in arbitrary order. wi’s list in J is her list in I together with the women in W\{wi} appended in arbitrary order. Proposition: Set of stable matchings in I = set of stable matchings in J Open question: can we reduce SR to SM?

17
**Efficient algorithm for SR**

Knuth (1976): is there an efficient algorithm for deciding whether there exists a stable matching, given an instance of SR? Irving (1985) “An efficient algorithm for the ‘Stable Roommates’ Problem”, Journal of Algorithms, 6: given an instance of SR, decides whether a stable matching exists; if so, finds one Algorithm is in two phases Phase 1: similar to GS algorithm for SM Phase 2: elimination of “rotations” if some list becomes empty during Phase 1 no stable matching exists if all lists are of length 1 after Phase 1 we have a stable matching, else: if some list becomes empty during Phase 2 no stable matching exists else Phase 2 finds a stable matching

18
**Stable Roommates with Ties (SRT)**

Ties are permitted in any preference list Example SRT instance: 1: (2 3) 4 2: 3: (1 4) 2 4: More than one stability definition is possible Super-stability A matching M in instance J of SRT is super-stable if there is no pair {p,q}M such that p strictly prefers q to his partner in M or is indifferent between them q strictly prefers p to his partner in M or is In any instance of SRT with no ties, super-stability is the same as classical stability Recall: an SR instance can have no stable matching

19
**Stable Roommates with Ties (SRT)**

Ties are permitted in any preference list Example SRT instance: 1: (2 3) 4 2: 3: (1 4) 2 4: More than one stability definition is possible Super-stability A matching M in instance J of SRT is super-stable if there is no pair {p,q}M such that p strictly prefers q to his partner in M or is indifferent between them q strictly prefers p to his partner in M or is In any instance of SRT with no ties, super-stability is the same as classical stability Recall: an SR instance can have no stable matching

20
**Stable Roommates with Ties (SRT)**

Ties are permitted in any preference list Example SRT instance: 1: (2 3) 4 2: 3: (1 4) 2 4: More than one stability definition is possible Super-stability A matching M in instance J of SRT is super-stable if there is no pair {p,q}M such that p strictly prefers q to his partner in M or is indifferent between them q strictly prefers p to his partner in M or is In any instance of SRT with no ties, super-stability is the same as classical stability Recall: an SR instance can have no stable matching

21
**SRT: super-stability (cont)**

Algorithm for finding a super-stable matching if one exists, given an SRT instance Irving and Manlove (2002) “The Stable Roommates Problem with Ties”, Journal of Algorithms, 43:85-105

22
**SRT: super-stability (cont)**

Algorithm for finding a super-stable matching if one exists, given an SRT instance Irving and Manlove (2002) “The Stable Roommates Problem with Ties”, Journal of Algorithms, 43:85-105 Algorithm is in two phases Phase 1: similar to SR case sequence of proposals and deletions persons become provisionally assigned to / assigned from other persons Example SRT instance: 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

23
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

24
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

25
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

26
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

27
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) 4: (1 3) 5: 6:

28
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) 4: (1 3) 5: 6:

29
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) 4: (1 3) 5: 6:

30
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) 4: (1 3) 5: 6:

31
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) 4: (1 3) 5: 6:

32
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) ,4 2 4: (1 3) ,3 5: 6:

33
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) ,4 2: 3: (5 4) ,4 2 4: (1 3) 5: 6:

34
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

35
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

36
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

37
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

38
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

39
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6:

40
**Phase 1 of Algorithm SRT-Super**

while (some person p has a non-empty list and p is not assigned to anyone) { for (each q at the head of p's list) { assign p to q; /* q is assigned from p */ for (each strict successor r of p in q's list) { if (r is assigned to q) break the assignment; delete the pair {q,r}; } if ( 2 persons are assigned to q) { break all assignments to q; for (each r tied with p in q's list) Example SRT instance: assigned to/from 1: 2: 3: 4: 5: 6:

41
After Phase 1: Lemma: if some person’s list is empty then no super-stable matching exists Lemma: if every person’s list has length 1 then the lists specify a super-stable matching If nobody’s list is empty and some person’s list has length >1 then we move on to Phase 2 1: 6 2: 3: 5 2 4: 2 5 5: 6: 1

42
After Phase 1: Lemma: if some person’s list is empty then no super-stable matching exists Lemma: if every person’s list has length 1 then the lists specify a super-stable matching If nobody’s list is empty and some person’s list has length >1 then we move on to Phase 2 1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Phase 2: “reject and reactivate Phase 1” select a person p whose list is of length >1 let p be rejected by first person on his list reactivate Phase 1

43
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1

44
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1

45
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1

46
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty

47
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1

48
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4

49
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4

50
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4

51
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4

52
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4

53
**Let person 2 be rejected by person 3 1: 6 2: 3 5 4 3: 5 2 4: 2 5 **

1: 6 2: 3: 5 2 4: 2 5 5: 6: 1 Person 3’s list is empty Reinstate the preference lists to their status after original Phase 1 Let p reject the last person on his list Reactivate Phase 1 Let person 2 reject person 4 Reactivation of Phase 1 terminates

54
1: 6 2: 3 3: 2 4: 5 5: 4 6: 1 All lists now have length 1 This corresponds to the matching {1,6}, {2,3}, {4,5} 1: (6 4) 2: 3: (5 4) 4: (1 3) 5: 6: The matching is super-stable with respect to the original lists

55
**Phase 2 of Algorithm SRT-Super**

T := preference lists generated by Phase 1; while (some person p’s list in T is of length > 1) { let q be the person assigned from p ; let r be the person assigned to p; form T1 from T by letting p be rejected by q; form T2 from T by letting p reject r; reactivate Phase 1 on T1; reactivate Phase 1 on T2; if (no list in T1 is empty) T := T1; else if (no list in T2 is empty) T := T2; else output “no super-stable matching exists”; } output T; /* which is a super-stable matching */

56
**Correctness of Algorithm SRT-Super **

Lemma 1: if T contains an embedded super-stable matching then either T1 or T2 contains an embedded super-stable matching Corollary 1: if T contains an embedded super-stable matching and T1 has an empty list then T2 contains an embedded super-stable matching Corollary 2: if each of T1 and T2 has an empty list then T contains no embedded super-stable matching Lemma 2: if T contains an embedded super-stable matching and T1 has no empty list then T1 contains an embedded super-stable matching T T1 T2

57
**Analysis of Algorithm SRT-Super**

Assume standard data structures: preference lists represented as doubly- linked lists embedded in an array ranking lists: for each person p, rankp(q) gives the position of q in p’s list These may be initialised in O(n2) time at outset With these data structures each deletion may be carried out in constant time Maintain a pointer to the last element in each person’s preference list Maintain a stack of persons waiting to propose Phase 1 is O(n+d) where d is the number of pairs deleted

58
**Analysis of Algorithm SRT-Super (cont)**

Computation of T1 and T2 during iteration i of main loop in Phase 2 is O(di1+di2) where dij is number of pairs deleted during each reactivation of Phase 1 Maintain two copies of the reduced lists at each iteration Initially make two copies, T1 and T2, of the preference lists - O(n2) time Thereafter, simulate parallel applications of Phase 1 on each of T1 and T2 Ensure that number of deletions from T1 never exceeds number of deletions from T2 by >1 (and vice versa) Maintain a stack of deletions from each E.g. if a list in T1 becomes empty, undo deletions of T1 and apply deletions of T2 Hence Phase 2 is O(n+d) where d is the total number of (non-redundant) pairs deleted Overall Algorithm SRT-Super has O(n2) complexity

59
SRT: strong stability A matching M in instance J of SRT is strongly stable if there is no pair {p,q}M such that p strictly prefers q to his partner in M q strictly prefers p to his partner in M or is indifferent between them Example SRT instance: 1: 2: (1 3) 4 3: 1 (4 2) 4: The matching is strongly stable. Polynomial-time algorithm for finding a strongly stable matching, or reporting that none exists, given an instance of SRT Scott (2004), PhD thesis (in preparation)

60
SRT: weak stability A matching M in instance J of SRT is weakly stable if there is no pair {p,q}M such that p strictly prefers q to his partner in M q strictly prefers p to his partner in M Example SRT instance: 1: 2: (1 3) 4 3: 4: The matching is weakly stable. The problem of deciding whether an instance of SRT admits a weakly stable matching is NP-complete Ronn (1990) “NP-complete Stable Matching Problems”, Journal of Algorithms, 11: Irving and Manlove (2002) “The Stable Roommates Problem with Ties”, Journal of Algorithms, 43:85-105

61
**Other extensions of SR Stable Crews Problem (SC)**

Each person p can have one of two roles, e.g. (A) Captain (pA) or (B) Navigator (pB) 1: 4B 3A 2A 2B 3B 4A 2: 1B 4A 3B 4B 1A 3A 3: 1A 2A 2B 4A 4B 1B 4: 2A 1B 2B 3B 1A 3A E.g. person 2 prefers person 1 as a navigator to person 4 as a captain

62
**Other extensions of SR Stable Crews Problem (SC)**

Each person p can have one of two roles, e.g. (A) Captain (pA) or (B) Navigator (pB) role 1: B 4B 3A 2A 2B 3B 4A 2: A 1B 4A 3B 4B 1A 3A 3: A 1A 2A 2B 4A 4B 1B 4: B 2A 1B 2B 3B 1A 3A E.g. person 2 prefers person 1 as a navigator to person 4 as a captain A matching M is a disjoint set of pairs of persons with roles each person is in exactly one pair each pair has exactly one Captain (A) and exactly one Navigator (B) e.g. {1B, 3A}, {2A, 4B}

63
**{XA,YB} is a blocking pair of M if**

(1) X prefers YB to his partner in M (2) Y prefers XA to his partner in M A matching is stable if it admits no blocking pair E.g. {2A, 3B} blocks the previous matching role 1: B 4B 3A 2A 2B 3B 4A 2: A 1B 4A 3B 4B 1A 3A 3: A 1A 2A 2B 4A 4B 1B 4: B 2A 1B 2B 3B 1A 3A 3: B 1A 2A 2B 4A 4B 1B 4: A 2A 1B 2B 3B 1A 3A The above matching is stable

64
**An instance I of SR can be reduced to an**

instance J of SC such that every stable matching in I corresponds to a stable matching in J and vice versa Some instances of SC do not admit a stable matching There is an efficient algorithm to find a stable matching, if one exists, given an instance of SC If crews are of size 3, the problem of deciding whether a stable matching exists is NP-complete Cechlárová and Ferková (2004) “The Stable Crews Problem”, Discrete Applied Mathematics, 140 (1-3): 1-17

65
**Stable Fixtures Problem (SF)**

Choose a schedule of fixtures based on teams having preferences over each other Two given teams can play each other at most once Each team i has a capacity ci , indicating the maximum number of fixtures it can play A fixture allocation A is a set of unordered pairs of teams {i, j} such that, for each i, team i is scheduled to play at most ci fixtures Example SF instance: team capacity preferences 1: 2: 3: 4:

66
**Stable Fixtures Problem (SF)**

Choose a schedule of fixtures based on teams having preferences over each other Two given teams can play each other at most once Each team i has a capacity ci , indicating the maximum number of fixtures it can play A fixture allocation A is a set of unordered pairs of teams {i, j} such that, for each i, team i is scheduled to play at most ci fixtures Example SF instance: team capacity preferences 1: 2: 3: 4: The above fixture allocation is: {1, 2}, {1, 4}, {2, 3}, {3, 4}

67
**A blocking pair of a fixture allocation A is a**

pair of teams {i , j}A such that: i is assigned fewer than ci teams in A or i prefers j to at least one of its assignees and j is assigned fewer than cj teams in A or j prefers i to at least one of its assignees A fixture allocation is stable if it admits no blocking pair Example SF instance: team capacity preferences 1: 2: 3: 4: The above fixture allocation is not stable as {1,3} is a blocking pair

68
Example SF instance: team capacity preferences 1: 2: 3: 4: The above fixture allocation is stable SR is a special case of SF (in which each team has capacity 1) There is an efficient algorithm to find a stable fixtures allocation, if one exists, given an instance of SF Irving and Scott (2004), “The Stable Fixtures Problem”, to appear in Discrete Applied Mathematics

69
**Stable Activities Problem (SA) Generalization of SC in which number of **

roles (“activities”) is arbitrary Problem is formulated in terms of a multigraph vertex for each person edge eA={u,v} indicates that u finds acceptable activity A with v u has a linear order over N(u) Stable Multiple Activities Problem (SMA) Generalization of SA in which each vertex v has a bound b(v) In any matching v is incident to at most b(v) edges In both cases we seek a stable matching Each of SA and SMA is reducible to SR Cechlárová and Fleiner (2003) “On a generalization of the stable roommates problem”, EGRES Technical Report No.

70
**Open questions Summary Stable Roommates problem (SR)**

Stable Roommates problem with Ties (SRT) super-stability strong stability weak stability Other extensions: Stable Crews problem (SC) Stable Fixtures problem (SF) Stable Activities problem (SA) Stable Multiple Activities problem (SMA) Open questions Reduction from SR to SM? Characterise Algorithm SRT-Super in terms of rotations, as in the SR case SA / SMA with ties

Similar presentations

Presentation is loading. Please wait....

OK

All Pair Shortest Path IOI/ACM ICPC Training June 2004.

All Pair Shortest Path IOI/ACM ICPC Training June 2004.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on limitation act 1908 Moving message display ppt online Ppt on front office operation Ppt on content development for iptv Ppt on memory management in os Ppt on air pollution monitoring Ppt on third generation solid state drives Ppt on bluetooth technology free download Ppt on java virtual machine Ppt on second law of thermodynamics entropy