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

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google