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