从总价值最高的 2 个 arrays 中从 N 个数中选择 k 个

Question

设A 、 B和C为三个 arrays，每个包含N个数字：

 A = a[0], a[1], a[2], ..., a[N-1] 
 B = b[0], b[1], b[2], ..., b[N-1]
 C = c[0], c[1], c[3], ..., c[N-1] 

我想 select A中的最佳k < N k < N元素和B中的最佳 k < N 元素，以便它们值的总和最大化。 有趣的转折是：如果元素i是从A和B中选择的（其中i in {0, ..., N-1}是索引），那么这些元素将代替a[i] + b[i] ，他们将贡献c[i]其中c[i] >= a[i] + b[i] 。

乍一看，这对我来说似乎很简单，但我想得越多，涉及的越多。

我最终在 Python 中寻找一个实现，但在这个阶段，我只是想了解什么是这里的有效算法。

---

例子

澄清一下，算法的输入是 3 N x 1 arrays A 、 B和C以及k的 integer 值。 预期的 output 是两个kx 1索引列表，定义了来自A和B的元素的值最大化组合（以及C ）。

例如，假设k = 2 ， N = 4并让

 A = a[0], a[1], a[2], a[3] = 3, 1, 1, 0   
 B = b[0], b[1], b[2], b[3] = 1, 3, 0, 1  
 C = c[0], c[1], c[2], c[3] = 4, 4, 3, 2

即使在这个简单的例子中，也有许多可能的组合。 例如，如果元素i = 0, 2从A中选择，元素j = 1, 3从B中选择，则总值将为a[0] + a[2] + b[1] + b[3] = 8 。

另一方面，如果元素i = 0, 1和j = 0, 1将从A和B中选择，那么特殊的扭曲适用：而不是产生a[0] + a[1] + b[0] + b[1] ，总值由c[0] + c[1] = 8给出。

在此示例中，使总值最大化的元素组合由A中的i = 0, 2和B中的元素j = 1, 2给出。 这产生 a a[0] + b[1] + c[2] = 9的总值，可以验证它比任何其他组合都多。

---

答案比较

这是 3 个提交的解决方案的快速比较。 首先，我检查了所有这些，它们都给出了预期的结果。 作为旁注，它们都不要求C的元素比A和B中相应元素的总和稍大，所以我在性能评估中放弃了这个假设。

这是我运行的：

import numpy as np
from utils import tic, toc  # simple wrapper to time.perf_counter()

k, N = 10, 1000

A = list(np.random.random_sample([N]))
B = list(np.random.random_sample([N]))
C = list(np.random.random_sample([N]))

tic()
print(optimal_choices(k, A, B, C))  # solution by btilly
toc()

tic()
print(maxPicks(A.copy(), B.copy(), C.copy(), k))  # solution by Eric T-M
toc()

tic()
print(maxSum(A, B, C, k))  # solution by Alain T.
toc()

我测试了k和N的各种组合。 只要k很小，@btilly 的算法似乎在N中可以很好地扩展。 @Alain-T. 的算法正好相反，当k相对于N很大时效果很好。 总的来说，@Eric-TM 的算法表现最好，在k和N中都可以很好地扩展。

小问题：k = 10 和 N = 500

• btilly的算法：0.49s
• Eric TM 的算法：0.00s
• Alain T.的算法：0.52s

小 k，大 N：k = 10 和 N = 1000

• btilly的算法：0.89s
• Eric TM 的算法：0.00s
• Alain T.的算法：1.99s

大 k，小 N：k = 80 和 N = 100

• btilly的算法：1.54s
• Eric TM 的算法：0.00s
• Alain T.的算法：0.09s

中等问题：k = 50 和 N = 1000

• btilly的算法：13.01ss
• Eric TM 的算法：0.00s
• Alain T.的算法：8.55s

大问题1：k = 10 and N = 1_000_000

• Eric TM 的算法：1.03s

大问题2：k = 1_000 and N = 100_000

• Eric TM 的算法：10.22s

（对于基准测试，我删除了 Alain T. 代码中的排序，以使其具有可比性。）

Answer 1

尝试这个。 它需要O(N^2)时间，而且相当简单。

def maxPicks(A,B,C,k):
    # returns the tuple (list of entries picked in A, list of entries picked in B, total value)

    # BASE CASE
    if k == 0:
        return ([], [], 0)
    aMax = max(A)
    bMax = max(B)
    cMax = max(C)

    if (aMax + bMax) > cMax:
        aIdx = A.index(aMax)
        bIdx = B.index(bMax)
        B[aIdx] = C[aIdx] - A[aIdx]
        A[aIdx] = -2
        C[aIdx] = -1
        A[bIdx] = C[bIdx] - B[bIdx]
        B[bIdx] = -2
        C[bIdx] = -1
        nextPicks = maxPicks(A,B,C,k-1)
        return (nextPicks[0] + [aIdx], nextPicks[1] + [bIdx], nextPicks[2] + aMax + bMax)
    else:
        cIdx = C.index(cMax)
        A[cIdx] = -1
        B[cIdx] = -1
        C[cIdx] = -1
        nextPicks = maxPicks(A,B,C,k-1)
        return (nextPicks[0] + [cIdx], nextPicks[1] + [cIdx], nextPicks[2] + cMax)

以下是它的工作原理：

基本情况应该是不言自明的。 否则，我们将比较A中所有条目的最大值和B中所有条目的最大值之和与C中所有条目的最大值之和。 如果这个总和大于从A和B中选择这些条目是安全的，但在进行更多选择之前，我们需要将我们选择的条目以及它们在C中的相应条目设置为负值。 作为旁注，我确实假设 A、B 和 C 中的所有值最初都是非负的，因此通过将它们设置为负，我们禁止我们的算法再次选择它们。 如果这个假设是错误的，您可能希望将这些值设置为非常负的值以禁止双重选择。 我们还看到，如果我们选择A[i] ， B[i]的值现在是C[i]-A[i]的值，因为选择B[i]将失去A[i]中的值并给出如果我们选择B[j] ，我们C[i]中的值与条目A[j]相同。

另一方面，如果C中的最大条目大于或等于aMax+bMax我们想要选择它（通过选择A和B中的相应条目，因为没有其他条目选择A和B或只是C单独使用会更有价值。此时我们知道我们不想重新选择A[i],B[i]或C[i] ，所以我们将它们都设置为负数。

Answer 2

这可以通过动态规划来解决。

# Helper function to get out of the data structure.
def get_nested_array (data, path):
    for x in path:
        if data is None or len(data) <= x:
            return None
        else:
            data = data[x]
    return data

# Helper function to set data in the data structure.
def set_nested_array (data, path, value):
    # Navigate there
    for x in path[0:len(path)-1]:
        while len(data) <= x:
            data.append([])
        if data[x] is None:
            data[x] = []
        data = data[x]
    while len(data) <= path[-1]:
        data.append(None)
    data[path[-1]] = value

# Is this option better than what is there?  If so, then add it.
def possibly_add_choice (best_choice, pos, i, j, current_sum, last_i, last_j):
    best_prev = get_nested_array(best_choice, [pos, i, j])
    if best_prev is None or best_prev[0] < current_sum:
        set_nested_array(best_choice, [pos, i, j], (current_sum, last_i, last_j))

# Our program.
def optimal_choices (k, A, B, C):
    # best_choice[pos][i][j] = (max_sum, last_a, last_b)
    # where:
    #    We have made all choices in the range 0..pos-1
    #    We chose i out of A
    #    We chose j out of B
    # and
    #    max_sum is the best possible sum
    #    last_a is the last index chosen from a
    #    last_b is the last index chosen from b
    # then we can find the answer working backwards from
    # best_choice[len(A)][k][k]
    #
    best_choice = []

    # Enter the empty set answer
    set_nested_array(best_choice, [0, 0, 0], (0, None, None))

    for pos in range(len(A)):
        best_choice.append([])
        best_choice_for_pos = best_choice[pos]
        for i in range(k+1):
            if len(best_choice_for_pos) <= i:
                break
            best_choice_for_i = best_choice_for_pos[i]
            for j in range(k+1):
                if len(best_choice_for_i) <= j:
                    break
                last_sum, last_i, last_j = best_choice_for_i[j]

                # Try all 4 things we can choose here.  Nothing, or A or B or both.
                possibly_add_choice(best_choice, pos+1, i, j, last_sum, last_i, last_j)
                possibly_add_choice(best_choice, pos+1, i+1, j, last_sum + A[pos], pos, last_j)
                possibly_add_choice(best_choice, pos+1, i, j+1, last_sum + B[pos], last_i, pos)
                possibly_add_choice(best_choice, pos+1, i+1, j+1, last_sum + C[pos], pos, pos)

    # Now we have the answer, it is just a question of decoding it.
    if get_nested_array(best_choice, [len(A), k, k]) is None:
        return (None, None)
    else:
        choose_a = []
        choose_b = []
        best_spot = [len(A), k, k]
        max_sum, last_i, last_j = get_nested_array(best_choice, best_spot)
        while last_i is not None or last_j is not None:
            # Figure out where we last had a choice and what was chosen.
            if last_i is None:
                last_pos = last_j
                i_dec = 0
                j_dec = 1
            elif last_j is None:
                last_pos = last_i
                i_dec = 1
                j_dec = 0
            else:
                last_pos = max(last_i, last_j)
                i_dec = 0
                j_dec = 0
                if last_pos == last_i:
                    i_dec = 1
                if last_pos == last_j:
                    j_dec = 1

            # record the choice.
            if 1 == i_dec:
                choose_a.append(last_pos)
            if 1 == j_dec:
                choose_b.append(last_pos)

            # Go back to that spot
            max_sum, last_i, last_j = get_nested_array(best_choice, [last_pos, k-len(choose_a), k-len(choose_b)])

        # We walked backwards to generate these lists.  So they are currently reversed.
        return (list(reversed(choose_a)), list(reversed(choose_b)))

print(optimal_choices(2, [3, 1, 1, 0 ], [1, 3, 0, 1], [4, 4, 3, 2]))

Answer 3

如果将 A 和 B 扩展为具有各自总和的索引对列表（应用 C 的例外），则可以迭代地获取最大总和并在每个步骤中排除相应的对。 这将 select 在每次迭代中剩余对的最高可能总数：

def maxSum(A,B,C,K):
    S = [ ([a+b,C[i]][i==j],i,j) for i,a in enumerate(A)  
                                 for j,b in enumerate(B)]
    usedA,usedB  = set(),set()
    for _ in range(K):
        _,i,j = max(s for s in S if not(s[1] in usedA or s[2] in usedB))
        usedA.add(i)
        usedB.add(j)
    return sorted(usedA),sorted(usedB)

output：

A = [3, 1, 1, 0]   
B = [1, 3, 0, 1]  
C = [4, 4, 3, 2]
print(maxSum(A,B,C,2)) # ([0, 2], [1, 2])   total is 9

A = [1,2,3,4]
B = [4,5,6,2]
C = [5,9,9,6]

print(maxSum(A,B,C,2)) # ([1, 3], [1, 2])  total is 19

print(maxSum(A,B,C,3)) # ([1, 2, 3], [0, 1, 2]) total is 26