Question

所以我一直在研究这个问题，这个问题与选择具有给定约束的最大子数组有关。问题如下：

Yuckdonalds正考虑在Quaint Valley Highway沿线开设一系列餐厅（QVH）。可能的位置沿着直线，以及它们的距离从QVH开始的位置，以英里为单位，按升序排列， M1;平方米; ::: ;; MN

约束如下：在每个地点，Yuckdonalds最多可以开一家餐馆。预期的从位置开设餐厅获利我是pi，其中pi> 0和i = 1; 2; ::: ;; Ñ

任何两家餐馆应至少相隔k英里，其中k为正整数。

我已将排序后的数组M视为二进制堆，我的算法包括迭代每个索引的二进制堆（在数组M中）并选择其左/右子的最大值，只要它满足距离约束k。然后以索引的左右子项递归调用函数。

我似乎正在选择一些最佳指数，因为这是输出显示的但是我错过了一些但我无法弄清楚是什么。 PS。这不是为了学校，它是一个多月以前，我现在编写它是为了好玩，我知道我的tempProfit变量现在没用了

def binHandle(parent, M, P, tmp, lc):

    lastchosen = lc
    i = parent
    left = 2*i
    right = 2*i + 1
    if left > len(M):
            return

    parent = M[parent]

    if right <= len(M) and left < len(M):
            childRestL = M[left]
            childRestR = M[right]

            #choose best child
            if distance(lastchosen, childRestL) >= k:
                    if P[right] > P[left]:
                            outcome = P[right]
                            lastchosen = M[right]
                            tmp += outcome
                            print outcome
                            binHandle(right , M, P, tmp, lastchosen)

                    else:
                            outcome = P[left]
                            lastchosen = M[left]
                            tmp += outcome
                            print outcome
                            binHandle(left , M, P, tmp, lastchosen)

def maxprofits(M, P, k):
    maxProf = 0
    global tempProfit
    tempProfit = 0
    n = 1

    #test each index in array
    for n in range(1, len(M)):
            binHandle(n, M, P, tempProfit, 0)
            if tempProfit > maxProf:
                    maxProf = tempProfit
            tempProfit = 0
    return maxProf

编辑：搞清楚了

Answer 1

基本递归如下：你有你的候选人集合。你决定是否去第一家餐馆。如果你这样做，你必须摆脱距离它太近的下一个候选者（距离＆lt; k）。如果你不这样做，你就摆脱了第一个位置并继续。在任何情况下，你继续检查你是否采取了剩下的设置的第一个位置，等等。

最后，你得到了最好的结果。现在，你的问题陈述了动态编程......这是一个很好的想法，因为我们将使用它来改进以前的算法。我们将从它的结尾开始并存储中间计算，而不是从完整数组开始，这是它的工作原理：

INPUTS： M[0..n-1], P[0..n-1]，M按递增顺序排序，P表示P [i]是与位置M [i]相关的利润

让S[0..n-1]成为数值的数组。我们为任何i设置S[i] = 0，除了n-1，其中S[n-1] = P[n-1]，然后我们将整数i设置为n-1。让R[0..n-1]成为列表数组。对于任何i R[i] = {}，除了n-1，R[n-1] = {n-1}
虽然我＆gt; = 0
1. 求j使得j = min（q∈[| i + 1，n-1 |]，M [q] -M [i]> k）。换句话说，我们找到满足距离标准的最小指数（在当前位置之后） 注意：为此，您可以在M [i + 1..n-1]上运行二进制搜索以查找M[i] + k。只需“调整”搜索过程即可返回第一次出现的严格优先而不是结果。
2. S [i] = max（P [i] + S [q]，S [i + 1]）（如果q不存在，则在前面的等式中考虑S [q] = 0）
3. 取决于哪个是最佳解决方案，R[i] <- {i} + R[q]或R[i] <- R[i+1]
S [0]现在是您可以获得的最佳利润。 R [0]是提供此最佳结果的所选位置的列表。

动态编程，带约束的最大子阵列

1 个答案: