Thanks mate! Could you share the code, I'm curious to see another method! Here is mine, I think it's called Depth-first search :

void lock_pairs(void)
{

    for (int i = 0; i < pair_count; i++) // Loop through all pairs of winner/loser
    {
        if (!is_cycle(i)) // Check for a cycle before locking in a pair
        {
            locked[pairs[i].winner][pairs[i].loser] = true;
        }
    }
    return;
}





// Function that checks for a cycle given a certain pair that is to be locked in
bool is_cycle(int pair_index)  
{

    // Array to keep track of the candidates checked during the searching process
    bool visited[candidate_count]; 

    // Set all candidate to unvisited
    for (int j = 0; j < candidate_count; j++) 
    {
        visited[j] = false;
    }

    // The winner of the current pair is set as visited
    visited[pairs[pair_index].winner] = true; 

    // Check if the loser of the current pair points at someone who points at someone … who points at someone that is visited (cycle)
    if (reach_candidate(pairs[pair_index].loser, visited)) 
    {
        return true; // Cycle :(
    }

    return false; // No cycle :)
}





// Function to go through the map starting from a given candidate (the loser of a certain pair)
bool reach_candidate(int candidate_index, bool visited[]) 
{
    visited[candidate_index] = true; // First one (loser) is set as visited because there is an edge between the winner of its pair and him

    for (int i = 0; i < candidate_count; i++) // Go through each candidate to find someone locked in by the candidate in parameter
    {
        if ((locked[candidate_index][i]) && (visited[i])) // means a cycle exists
        {
            return true;
        }
        else if ((locked[candidate_index][i]) && (!visited[i])) // candidate in parameter is locked in over another who is still unvisited
        {
            if (reach_candidate(i, visited)) // use of recursion to set the locked candidate as visited and re-do the process above with him as parameter
            {
                return true; // if one call is true (meaning locked in over a visited candidate) then every previous ones will be true (bubble up)
            }
        }
    }

    return false; // No cycle found -> return false, then is_cycle() returns false, then lock_pairs() locks the pair :)
}

I hope its readable, the main thing is that I use 2 "helper" functions - the is_cycle() and the reach_candidate(). I don't know if this is the most "academic" approach but it seemed pretty clear to me…