greedy_algorithms::stable_matching Namespace Reference

Functions for the Gale-Shapley Algorithm. More...

Functions
std::vector< std::uint32_t >	gale_shapley (const std::vector< std::vector< std::uint32_t > > &secondary_preferences, const std::vector< std::vector< std::uint32_t > > &primary_preferences)
	The main function that finds the stable matching between two sets of elements using the Gale-Shapley Algorithm.

Detailed Description

Functions for the Gale-Shapley Algorithm.

Function Documentation

gale_shapley()

std::vector< std::uint32_t > greedy_algorithms::stable_matching::gale_shapley	(	const std::vector< std::vector< std::uint32_t > > &	secondary_preferences,
		const std::vector< std::vector< std::uint32_t > > &	primary_preferences )

The main function that finds the stable matching between two sets of elements using the Gale-Shapley Algorithm.

Note

This doesn't work on negative preferences. the preferences should be continuous integers starting from 0 to number of preferences - 1.

Parameters

primary_preferences	the preferences of the primary set should be a 2D vector
secondary_preferences	the preferences of the secondary set should be a 2D vector

Returns

matches the stable matching between the two sets

                                                                                                                                                                  {
    std::uint32_t num_elements = secondary_preferences.size();
    std::vector<std::uint32_t> matches(num_elements, -1);
    std::vector<bool> is_free_primary(num_elements, true);
    std::vector<std::uint32_t> proposal_index(num_elements, 0); // Tracks the next secondary to propose for each primary
 
    while (true) {
        int free_primary_index = -1;
 
        // Find the next free primary
        for (std::uint32_t i = 0; i < num_elements; i++) {
            if (is_free_primary[i]) {
                free_primary_index = i;
                break;
            }
        }
 
        // If no free primary is found, break the loop
        if (free_primary_index == -1) break;
 
        // Get the next secondary to propose
        std::uint32_t secondary_to_propose = primary_preferences[free_primary_index][proposal_index[free_primary_index]];
        proposal_index[free_primary_index]++;
 
        // Get the current match of the secondary
        std::uint32_t current_match = matches[secondary_to_propose];
 
        // If the secondary is free, match them
        if (current_match == -1) {
            matches[secondary_to_propose] = free_primary_index;
            is_free_primary[free_primary_index] = false;
        } else {
            // Determine if the current match should be replaced
            auto new_proposer_rank = std::find(secondary_preferences[secondary_to_propose].begin(),
                                                secondary_preferences[secondary_to_propose].end(),
                                                free_primary_index);
            auto current_match_rank = std::find(secondary_preferences[secondary_to_propose].begin(),
                                                 secondary_preferences[secondary_to_propose].end(),
                                                 current_match);
 
            // If the new proposer is preferred over the current match
            if (new_proposer_rank < current_match_rank) {
                matches[secondary_to_propose] = free_primary_index;
                is_free_primary[free_primary_index] = false;
                is_free_primary[current_match] = true; // Current match is now free
            }
        }
    }
 
    return matches;
}

Here is the call graph for this function: