python遍历团队组合

Question

I have a list of 10 players, each with a respective skill score. I'm trying to organise them into 2 teams of 5, where the total skill score of each team is as close as possible.

Iterating over every combination is obviously not very efficient as identical teams will occur.

Is there a python library or function that can either efficiently solve this problem or at least just iterate over the correct combinations?

Iterating over 10! combinations isn't so bad if that is the easiest answer.

Answer 1

As you said finding the perfect solution is very complex for this problem set, but you can try using greedy approach.

Say each player 'P' has these skills score bowling(bw) batting(b) & fielding(f) now you can come up with an equation for aggregated skill(K) with sample equation K = 2*bw+2*b+f

Now all you have to do is split the 10 players into 2 teams with each k/2+k/2 approximately, which is straightforward if you use greedy approach.

Greedy algorithm:

1. Sort all the player in descending order by their aggregated skill score(K).
2. Maintain two sides A & B
3. Add the highest scorer to team A
4. Add the second highest scorer to team B
5. Keep adding the next scorer to the lowest total's team

You can find the implementation here in Wikipedia

def find_partition(int_list):
    "returns: An attempt at a partition of `int_list` into two sets of equal sum"
    A = set()
    B = set()
    for n in sorted(int_list, reverse=True):
        if sum(A) < sum(B):
           A.add(n)
        else:
           B.add(n)
    return (A, B)

Update : The above code doesn't consider the quality of team size, Regarding that here might be useful discussion

https://cs.stackexchange.com/questions/33697/partition-partition-with-constraint-of-equal-size

Answer 2

While not a perfect solution, could you take the average player skill and rank the n players based on this average.

Then based on these values, use some heuristic to try and "balance" out these players across the two teams. Simple example would be to assign teams like so (highest ranked = 10, lowest ranked = 1)

Team 1 = 10 7 6 3 1

Team 2 = 9 8 5 4 2

Again, not perfect, but much less expensive than 10! search.

Answer 3

I solved this problem with itertools.combinations and sets, by going through each combination of the first team and using the remaining players as the second team, the search space was reduced to only 252 combinations.

from itertools import combinations

# random dictionary of players and scores
players = {
    'abc': 1234,
    'bcd': 2345,
    'cde': 3456,
    'def': 4567,
    'efg': 5678,
    'fgh': 6789,
    'ghi': 7891,
    'hij': 8912,
    'ijk': 9123,
    'jkl': 7410
}

closest_difference = None
all_players_set = set(players.keys())

for team_a in combinations(players.keys(), 5):
    team_a_set = set(team_a)
    team_b_set = all_players_set - team_a_set

    team_a_total = sum([players[x] for x in team_a_set])
    team_b_total = sum([players[x] for x in team_b_set])

    score_difference = abs(team_a_total - team_b_total)

    if not closest_difference or score_difference < closest_difference:
        closest_difference = score_difference
        best_team_a = team_a_set     
        best_team_b = team_b_set  

print("\nTeam a:")

for player in best_team_a:
    print(player)
print("with a score of " + str(sum([players[x] for x in best_team_a])))

print("\nTeam b:")

for player in best_team_b:
    print(player)
print("with a score of " + str(sum([players[x] for x in best_team_b])))