在保持平衡的同时将不良玩家与优秀玩家配对

时间：2018-06-30 19:05:34

标签： python python-3.x algorithm permutation

我有很多球员分为好球员和坏球员两类。每个玩家都由一个算术值定义，可能的分组可能是这个：

bad players
A 13
B 6
C 9
D 2

good players
X 25
Y 16
Z 17
K 10

将一个好球员与一个坏球员配对会导致他的差值等于该坏球员的价值（因此，如果我将一个价值100的好球员与一个价值50的坏球员配对，那么好球员值下降到50）。我需要将每个好玩家与一个坏玩家配对，但是这样才能使结果列表中的好玩家的总和可以分成两组，它们的大小相同且总和相同。

在上面的示例中，配对错误是：

A - X 12
C - Z 8
B - Y 10
D - K 8

现在，由于与好手（A B C D）配对，所有好手都失去了一些分，他们的价值已经改变。这些新值不能分为大小相等的两组，以便每组中的值之和相等。如果我有其他组合，请说：

D - K 8
B - Z 11
C - X 16
A - Y 3

我现在可以将好玩家分为 K，Z 和 X，Y ，它们的值都为 19 ，依此类推事情保持中立。

要找到一个可以接受的好人和坏人配对的解决方案，就是使用蛮力并产生所有可能的组合，然后通过尝试将其分为两组来检查每个组合是否可接受相等的价值。找到第一个可接受的解决方案后，我们将其退回。

如何改善此设置并直接在此设置中找到可接受的配对？

2 个答案:

答案 0 :(得分：4)

这是一个相当有效的算法。小型数据集可以，但是大型数据集需要花费时间和RAM。我不会说这是 best 的算法，但肯定比蛮力检查每一个好-不好的配对要好得多。

关键见解是，我们无需查看各个团队的良好（不良）配对，而可以查看整个团队的总体良好（不良）分数。假设两个有效球队的得分为（X，A）和（Y，B）。也就是说，X是团队1中所有好球员的总分，A是团队1中所有坏球员的总分。类似地，Y是团队2中好球员的总分，而B是团队2中好球员的总分。那支球队的坏球员。然后

X - A = Y - B
X + B = Y + A
2(X + B) = X + B + Y + A
X + B = (X + B + Y + A) / 2
Let M = (X + Y + A + B) / 2
Thus B = M - X

所以我们只需要计算M，即所有球员的得分之和，然后对于每个良好的球员分区X，我们需要查看是否存在匹配的不良球员分区B。（顺便说一下，上面的算法表明X +对于一个解，Y + A + B必须是偶数，因为B＆X必须是整数。

为了以合理的效率做到这一点，我们创建了一个坏玩家分区的字典。 dict键是该分区的总得分，相关值是具有该得分的所有不良播放器分区的列表。

然后，我们遍历良好的播放器分区对。我们找到一对中第一个分区的总分，将其从M中减去以获得所需的不良分数，然后查看字典中是否存在该不良分数。如果是这样，我们已经找到了解决方案。

函数equal_parts是我在纯Python中知道的将列表拆分为所有等长分区的最快方法，有关详细信息，请参见我几年前写的this answer。

下面的代码为问题中给出的数据找到一个解决方案；该解决方案为每个团队提供2个选择。我包括一些额外的代码（当前已注释掉），以生成一些随机的伪数据，以便在更大的数据集上测试代码。

更新

先前版本的逻辑中有一个小错误。当我找到具有正确总分b1的不良分区列表时，我使用bad_total - b1来获取另一支球队的不良分区的补充列表。但这并不总是能正常工作。 ：oops：新版本使用bad_parts字典，该字典将每个坏分区都存储为键和值，这使得容易获得正确的互补分区。

此外，旧的make_pairs函数有点草率，因此它可以生成共享玩家的Team 1列表和Team 2列表。 ：其他糟糕：现在，我们有了一个新功能make_teams，它调用了已修复的make_pairs。 make_teams函数在各节中打印各个小组1和小组2排列。在每个部分中，没有第1队列表会与第2队列表共享玩家。

我还做了其他一些小的更改，主要是分区元组中的名称始终按字母顺序排序。这使得它们用作字典键的功能更强大。我还对输出格式进行了一些调整。

有时（例如，在注释中提供的数据的解决方案23中）会发生所谓的解决方案不起作用的情况：没有不良球员的排列，可以与优质球员相结合而不会产生负得分。希望这不是主要问题。为了使代码能够自动处理，我们需要对其进行更改，以便与其按行打印结果，而无需将结果存储在列表中（或使用生成器），然后测试结果列表是否为在打印该解决方案之前将其清空。这将消耗更多的RAM，并使逻辑比目前的逻辑更加混乱。

from itertools import combinations, permutations
from collections import defaultdict
from random import seed, randrange

seed(37)

def equal_parts(lst):
    ''' yield all equal-sized pair partitions of lst '''
    first = lst[0]
    allset_diff = set(lst).difference
    for left in combinations(lst, len(lst) // 2):
        if left[0] != first:
            break
        yield left, tuple(sorted(allset_diff(left)))

def find_partitions(bad, good):
    print('bad', bad, len(bad))
    print('good', good, len(good))

    bad_total = sum(bad.values())
    good_total = sum(good.values())
    total = bad_total + good_total
    if total % 2 != 0:
        print('No solutions!')
        return

    magic = total // 2
    print('magic =', magic)

    # Create a dict of the good partition pairs
    good_parts = dict(equal_parts(sorted(good)))
    # Create a dict of the bad partition pairs, with each partition of 
    # the pair as a key and the complementary partiton as the value
    bad_parts = {}
    for bpart1, bpart2 in equal_parts(sorted(bad)):
        bad_parts[bpart1] = bpart2
        bad_parts[bpart2] = bpart1
    #print(bad_parts)

    # Get the sums of all the bad partitions, and save them in 
    # a dict of lists with the partition sum as the key and 
    # the partition in the value list
    bad_sums = defaultdict(list)
    for bpart in bad_parts:
        s = sum(bad[k] for k in bpart)
        bad_sums[s].append(bpart)
    bad_sums = dict(bad_sums)
    #print(bad_sums)

    # Sum the 1st of each pair of good partitions & see if there's a matching bad partition 
    count = 0
    for gpart1, gpart2 in good_parts.items():
        g1 = sum(good[k] for k in gpart1)
        b1 = magic - g1
        if b1 in bad_sums:
            count += 1
            print('SOLUTION', count)
            g2 = good_total - g1
            b2 = bad_total - b1
            blist1 = bad_sums[b1]
            # Create the complementary list of bad partitions
            blist2 = [bad_parts[k] for k in blist1]
            tot1 = g1 - b2
            tot2 = g2 - b1
            print(gpart1, g1, '-', blist2, b2, '=', tot1)
            print(gpart2, g2, '-', blist1, b1, '=', tot2, '\n')
            make_teams(gpart1, gpart2, blist1, blist2)

def make_pairs(gpart, bpart):
    for b in permutations(bpart):
        total = 0
        team = []
        for gkey, bkey in zip(gpart, b):
            score = good[gkey] - bad[bkey]
            if score <= 0:
                # Invalid pairing
                break
            total += score
            team.append('{}-{}={}'.format(gkey, bkey, score))
        else:
            print(', '.join(team), total)

def make_teams(gpart1, gpart2, blist1, blist2):
    section = 0
    for bpart2, bpart1 in zip(blist2, blist1):
        section += 1
        print('Section', section)
        print('Team 1:', ' '.join(gpart1), '+', ' '.join(bpart2))
        make_pairs(gpart1, bpart2)
        print('\nTeam 2:', ' '.join(gpart2), '+', ' '.join(bpart1))
        make_pairs(gpart2, bpart1)
        print()

# Make some fake data
def make_data(letters, lo, hi):
    return {s: randrange(lo, hi) for s in letters}

#while True:
    #bad = make_data('ZYXWVU', 1, 15)
    #good = make_data('ABCDEF', 10, 30)
    #bad_total = sum(bad.values())
    #good_total = sum(good.values())
    #if bad_total % 2 == good_total % 2:
        #break

bad = {'A': 13, 'B': 6, 'C': 9, 'D': 2,}
good = {'X': 25, 'Y': 16, 'Z': 17, 'K': 10,}

#bad = {'bA': 7, 'bB': 10, 'bC': 2, 'bD': 12, 'bE': 15, 'bF': 14, 'bG': 17, 'bH': 15} 
#good = {'gA': 19, 'gB': 36, 'gC': 9, 'gD': 15, 'gE': 24, 'gF': 23, 'gG': 24, 'gH': 24}

find_partitions(bad, good)

输出 

bad {'A': 13, 'B': 6, 'C': 9, 'D': 2} 4
good {'X': 25, 'Y': 16, 'Z': 17, 'K': 10} 4
magic = 49
SOLUTION 1
('K', 'Z') 27 - [('B', 'D')] 8 = 19
('X', 'Y') 41 - [('A', 'C')] 22 = 19 

Section 1
Team 1: K Z + B D
K-B=4, Z-D=15 19
K-D=8, Z-B=11 19

Team 2: X Y + A C
X-A=12, Y-C=7 19
X-C=16, Y-A=3 19

这是假数据的输出。

bad {'Z': 2, 'Y': 9, 'X': 5, 'W': 6, 'V': 11, 'U': 12} 6
good {'A': 23, 'B': 28, 'C': 28, 'D': 21, 'E': 28, 'F': 11} 6
magic = 92
SOLUTION 1
('A', 'B', 'C') 79 - [('U', 'V', 'Y')] 32 = 47
('D', 'E', 'F') 60 - [('W', 'X', 'Z')] 13 = 47 

Section 1
Team 1: A B C + U V Y
A-U=11, B-V=17, C-Y=19 47
A-U=11, B-Y=19, C-V=17 47
A-V=12, B-U=16, C-Y=19 47
A-V=12, B-Y=19, C-U=16 47
A-Y=14, B-U=16, C-V=17 47
A-Y=14, B-V=17, C-U=16 47

Team 2: D E F + W X Z
D-W=15, E-X=23, F-Z=9 47
D-W=15, E-Z=26, F-X=6 47
D-X=16, E-W=22, F-Z=9 47
D-X=16, E-Z=26, F-W=5 47
D-Z=19, E-W=22, F-X=6 47
D-Z=19, E-X=23, F-W=5 47

SOLUTION 2
('A', 'B', 'D') 72 - [('U', 'V', 'Z'), ('V', 'X', 'Y')] 25 = 47
('C', 'E', 'F') 67 - [('W', 'X', 'Y'), ('U', 'W', 'Z')] 20 = 47 

Section 1
Team 1: A B D + U V Z
A-U=11, B-V=17, D-Z=19 47
A-U=11, B-Z=26, D-V=10 47
A-V=12, B-U=16, D-Z=19 47
A-V=12, B-Z=26, D-U=9 47
A-Z=21, B-U=16, D-V=10 47
A-Z=21, B-V=17, D-U=9 47

Team 2: C E F + W X Y
C-W=22, E-X=23, F-Y=2 47
C-W=22, E-Y=19, F-X=6 47
C-X=23, E-W=22, F-Y=2 47
C-X=23, E-Y=19, F-W=5 47
C-Y=19, E-W=22, F-X=6 47
C-Y=19, E-X=23, F-W=5 47

Section 2
Team 1: A B D + V X Y
A-V=12, B-X=23, D-Y=12 47
A-V=12, B-Y=19, D-X=16 47
A-X=18, B-V=17, D-Y=12 47
A-X=18, B-Y=19, D-V=10 47
A-Y=14, B-V=17, D-X=16 47
A-Y=14, B-X=23, D-V=10 47

Team 2: C E F + U W Z
C-U=16, E-W=22, F-Z=9 47
C-U=16, E-Z=26, F-W=5 47
C-W=22, E-U=16, F-Z=9 47
C-Z=26, E-U=16, F-W=5 47

SOLUTION 3
('A', 'B', 'E') 79 - [('U', 'V', 'Y')] 32 = 47
('C', 'D', 'F') 60 - [('W', 'X', 'Z')] 13 = 47 

Section 1
Team 1: A B E + U V Y
A-U=11, B-V=17, E-Y=19 47
A-U=11, B-Y=19, E-V=17 47
A-V=12, B-U=16, E-Y=19 47
A-V=12, B-Y=19, E-U=16 47
A-Y=14, B-U=16, E-V=17 47
A-Y=14, B-V=17, E-U=16 47

Team 2: C D F + W X Z
C-W=22, D-X=16, F-Z=9 47
C-W=22, D-Z=19, F-X=6 47
C-X=23, D-W=15, F-Z=9 47
C-X=23, D-Z=19, F-W=5 47
C-Z=26, D-W=15, F-X=6 47
C-Z=26, D-X=16, F-W=5 47

SOLUTION 4
('A', 'C', 'D') 72 - [('U', 'V', 'Z'), ('V', 'X', 'Y')] 25 = 47
('B', 'E', 'F') 67 - [('W', 'X', 'Y'), ('U', 'W', 'Z')] 20 = 47 

Section 1
Team 1: A C D + U V Z
A-U=11, C-V=17, D-Z=19 47
A-U=11, C-Z=26, D-V=10 47
A-V=12, C-U=16, D-Z=19 47
A-V=12, C-Z=26, D-U=9 47
A-Z=21, C-U=16, D-V=10 47
A-Z=21, C-V=17, D-U=9 47

Team 2: B E F + W X Y
B-W=22, E-X=23, F-Y=2 47
B-W=22, E-Y=19, F-X=6 47
B-X=23, E-W=22, F-Y=2 47
B-X=23, E-Y=19, F-W=5 47
B-Y=19, E-W=22, F-X=6 47
B-Y=19, E-X=23, F-W=5 47

Section 2
Team 1: A C D + V X Y
A-V=12, C-X=23, D-Y=12 47
A-V=12, C-Y=19, D-X=16 47
A-X=18, C-V=17, D-Y=12 47
A-X=18, C-Y=19, D-V=10 47
A-Y=14, C-V=17, D-X=16 47
A-Y=14, C-X=23, D-V=10 47

Team 2: B E F + U W Z
B-U=16, E-W=22, F-Z=9 47
B-U=16, E-Z=26, F-W=5 47
B-W=22, E-U=16, F-Z=9 47
B-Z=26, E-U=16, F-W=5 47

SOLUTION 5
('A', 'C', 'E') 79 - [('U', 'V', 'Y')] 32 = 47
('B', 'D', 'F') 60 - [('W', 'X', 'Z')] 13 = 47 

Section 1
Team 1: A C E + U V Y
A-U=11, C-V=17, E-Y=19 47
A-U=11, C-Y=19, E-V=17 47
A-V=12, C-U=16, E-Y=19 47
A-V=12, C-Y=19, E-U=16 47
A-Y=14, C-U=16, E-V=17 47
A-Y=14, C-V=17, E-U=16 47

Team 2: B D F + W X Z
B-W=22, D-X=16, F-Z=9 47
B-W=22, D-Z=19, F-X=6 47
B-X=23, D-W=15, F-Z=9 47
B-X=23, D-Z=19, F-W=5 47
B-Z=26, D-W=15, F-X=6 47
B-Z=26, D-X=16, F-W=5 47

SOLUTION 6
('A', 'D', 'E') 72 - [('U', 'V', 'Z'), ('V', 'X', 'Y')] 25 = 47
('B', 'C', 'F') 67 - [('W', 'X', 'Y'), ('U', 'W', 'Z')] 20 = 47 

Section 1
Team 1: A D E + U V Z
A-U=11, D-V=10, E-Z=26 47
A-U=11, D-Z=19, E-V=17 47
A-V=12, D-U=9, E-Z=26 47
A-V=12, D-Z=19, E-U=16 47
A-Z=21, D-U=9, E-V=17 47
A-Z=21, D-V=10, E-U=16 47

Team 2: B C F + W X Y
B-W=22, C-X=23, F-Y=2 47
B-W=22, C-Y=19, F-X=6 47
B-X=23, C-W=22, F-Y=2 47
B-X=23, C-Y=19, F-W=5 47
B-Y=19, C-W=22, F-X=6 47
B-Y=19, C-X=23, F-W=5 47

Section 2
Team 1: A D E + V X Y
A-V=12, D-X=16, E-Y=19 47
A-V=12, D-Y=12, E-X=23 47
A-X=18, D-V=10, E-Y=19 47
A-X=18, D-Y=12, E-V=17 47
A-Y=14, D-V=10, E-X=23 47
A-Y=14, D-X=16, E-V=17 47

Team 2: B C F + U W Z
B-U=16, C-W=22, F-Z=9 47
B-U=16, C-Z=26, F-W=5 47
B-W=22, C-U=16, F-Z=9 47
B-Z=26, C-U=16, F-W=5 47

PS。我想到了一种快速处理大型数据集的方法。它不会找到所有 解决方案，但应该可以找到很多解决方案。想法是将大数据集划分为几个较小的集合，分别解决这些较小的集合，然后组合解决方案。唯一棘手的部分是进行除法，以便每个较小的集合都可求解。因此，在每个集合bad_total < good_total和bad_total%2 == good_total%2中。在尝试进行除法之前，按分数对完整数据集进行排序可能很有意义，这样每个较小的数据集的好坏组就可以大致匹配。

答案 1 :(得分：3)

以下代码将产生有效的配对分区：

<div class="container">
  <header>Header</header>
  <main>Main</main>
  <footer>Footer</footer>

  <div id="left_ad1">Left ad 1</div>
  <div id="left_ad2" class="ad">Left ad 2</div>
  <div id="right_ad1" class="ad">Right ad 1</div>
  <div id="right_ad2" class="ad">Right ad 2</div>
</div>

示例输出：from itertools import permutations def find_pairing_partitioning(scores_g, scores_b): keys_g = sorted(scores_g.keys()) keys_b = sorted(scores_b.keys()) # Some initialization that we can do once all_sum = sum(scores_g.values()) - sum(scores_b.values()) if all_sum % 2 == 1: raise RuntimeError("Can't evenly partition an odd sum") bin_siz = len(scores_g) // 2 # How many elements we want in each bin for perm_b in permutations(keys_b): diff = {} for (kg,kb) in zip(keys_g, perm_b): kr = '%s-%s' % (kg,kb) diff[kr] = scores_g[kg] - scores_b[kb] for perm_d in permutations(diff.keys()): # Note: Inefficient bin1_keys = perm_d[:bin_siz] bin2_keys = perm_d[bin_siz:] bin1_sum = sum(diff[k] for k in bin1_keys) bin2_sum = sum(diff[k] for k in bin2_keys) if bin1_sum == bin2_sum: yield bin1_keys, bin2_keys scores_g = {'X':25, 'Y':16, 'Z':17, 'K':10} # Scores, good players scores_b = {'A':13, 'B':6, 'C':9, 'D':2} # Scores, bad players bin1_keys, bin2_keys = next(find_pairing_partitioning(scores_g, scores_b)) print("Found even partitioning:", bin1_keys, "vs", bin2_keys)

内部排列调用效率很低，因为它多次测试有效的相同分区，例如：

    A,B  vs.  C,D
    B,A  vs.  C,D
    C,D  vs.  A,B
    ...

因此，您可能会考虑进行清理，或者将运行时效率换成空间效率和do something like this。

相关问题
最新问题