How can I evenly distribute league matchups across multiple locations using C#?

One scalable improvement is to “batch‐solve” the assignment for each week rather than assigning one match at a time. In your current version you’re doing a greedy assignment per match. However, if you “look ahead” by considering all match–to–location assignments for that week simultaneously you can guarantee a more even distribution.

A common technique for doing this is to treat the problem for each week as an assignment (or matching) problem. For example, for a week with X matches and X locations you can build an X×X cost matrix where the cost for match i to location j is the sum of the current counts (or weights) for the two teams at that location. Then, by solving the assignment problem (for example, using the Hungarian algorithm), you’re assigning locations in a globally optimal way for that week—minimizing the overall “imbalance.”

In short, the new algorithm would be:

1. For each week:
   • Build a cost matrix where the (i, j) entry is:
     cost[i][j] = locationWeight[match[i].AwayTeam][j] + locationWeight[match[i].HomeTeam][j]
   • Run the Hungarian algorithm (or another minimum-cost matching algorithm) on the cost matrix to produce a perfect matching between matches and locations.
   • Assign each match its determined location.
   • Now update the weights for the teams based on the assignment.
2. Continue week by week.

This way, you’re not just picking the current “lowest cost” for each match in isolation (which may later force a high cost choice for another match) but rather finding an assignment that minimizes the total imbalance for that week.

Below is an example code snippet outlining the idea:

---

CSHARPCopied
// For each scheduled week
schedule.GetAllScheduledRecords().ForEach(sr =>
{
    var weekMatches = sr.GetAllLeagueMatches();
    int numLocations = weekMatches.Count;
    
    // Build the cost matrix: rows represent matches, columns represent locations.
    // cost[i][j] is the cost for assigning match i to location j.
    var costMatrix = new int[numLocations, numLocations];
    for (int i = 0; i < numLocations; i++)
    {
        var lm = weekMatches[i];
        for (int j = 0; j < numLocations; j++)
        {
            costMatrix[i, j] = locationWeight[lm.GetAwayTeam()][j] + 
                                 locationWeight[lm.GetHomeTeam()][j];
        }
    }
    
    // Solve the assignment problem for this week.
    // Note: You need an implementation of the Hungarian algorithm (or similar) that returns 
    // an array assigning each row (match) to a column (location).
    int[] assignment = HungarianAlgorithm.Solve(costMatrix);
    
    // For each match, update the assignment and weight counts.
    for (int i = 0; i < numLocations; i++)
    {
        int chosenLocation = assignment[i];
        var lm = weekMatches[i];
        locationAssignments[chosenLocation][sr.GetLeagueWeek() - 1] = lm;
        locationWeight[lm.GetAwayTeam()][chosenLocation]++;
        locationWeight[lm.GetHomeTeam()][chosenLocation]++;
    }
});

---

Implementation Notes

• Hungarian Algorithm:
  You can find many implementations of the Hungarian algorithm in C#. There are open–source libraries (or you can implement your own) that accept a cost matrix and return an optimal assignment.

• Scalability:
  With this approach you’re solving an O(n³) problem per week (where n is the number of match-ups in a week). For most league sizes this should be perfectly acceptable. For larger leagues, you might consider heuristic or other optimization techniques.

• Generalization:
  This approach naturally scales if the number of matches per week or weeks in a session changes. All you’re doing is building and solving a fresh assignment problem for each week using the current weights from all previous assignments.

Using a global matching algorithm like this allows you to balance the overall distribution more evenly than a greedy per–match approach and lets you easily adapt to different league sizes and weekly match counts.

This modification should help you get as even a distribution as possible—for example, ensuring that with 8 teams (4 matches a week) each team gets 4 or as close as possible assignments at every location over the season, and similarly for other league sizes like 12 teams.