贪心算法按顺序找到潜在的加权活动？

Question

例如，假设有一个活动列表 {a, b, c, d, e, f, g}

a & b 各得 9 分。 c 值 8 分。 d & e 各得 6 分。 f 值 5 分。 g 值 4 分。

活动列表已按点数降序排列。

我想找到满足某些要求（例如 F(X) = true）的三个活动的最高分组合（我们称之为组合 X）。

F(X) 只接受三个活动的组合，不能修改。

如何在不必先计算所有可能的组合的情况下生成 X？
如何迭代所有可能的组合以减少总分？

我希望能够找到最高点组合，测试一下。如果失败，则生成第二高点组合等。

示例列表只有几个项目。但是，实际列表可能会变得非常大，生成所有组合是不切实际的。

我应该怎么做？

Answer 1

下面的想法只解决了问题的一个更简单的版本，但也许它可以扩展到更强大的解决方案。

令 [a(1)..a(N)] 为输入数组。 我在这里建议的是一种在完整枚举中从 C(N,3)~N^3 个中枚举前 N^(1/3) 个三元组的方法。我知道这是适度的，但它保证了 O(N) 时间和空间。

1. s = a(1) + a(2) + a(N^(1/3))
2. T = [a(1),a(2), .. ,a(N^(1/3))] 中的所有三元组（占用 O(N) 时间和空间）
3. 对 T 进行降序排列（时间复杂度：O(N^(1/3) * log N) = O(N) ）
4. 迭代 T 并返回每个三元组 r 而 sum(r) >= s

说明：

在 (1) 中，我们为不只涉及 T = [a(1)..a(N^(1/3))] 的项目的三元组计算可能的最高分。换句话说，T 已经包含了所有 score > s 的三元组。因此，我们在 T 中生成所有三元组，对它们进行排序，然后只返回我们确定的那些（即 score>=s 的那些）。将返回多少个这样的三胞胎？好吧，这取决于数组值，但我们可以保证至少 N^(1/3) - 2 个三元组，因为 2<i<=N^(1/3) 的所有三元组 [a(1)+a(2)+a(i)] 都有总和 >=s。在实践中，“好”三元组的数量可能要高得多，但这同样取决于数组编号分布。

Answer 2

这是生成三个有序组合的方法：-

    for(int i=0;i<Set.size();i++) {

       for(int j=i+1;j<Set.size();j++) {

           for(int k=j+1;k<Set.size();k++) {

                   if(F(Set[i],Set[j],Set[k])) {
                       // your code to find max
                   }  
           }
       }

}

Answer 3

我认为没有很好的解决方案可以满足您的要求。这是我能想到的最好（也是最差）的解决方案：生成所有组合，将它们放在一个向量中然后排序！复杂度为O(n^3 log(n^3))。我认为通过假设在同一位置多次具有相同值没有意义，因为它会生成一个已经生成的组合，我认为只能实现一点点改进。

c++实现：

#include <stdio.h>
#include <algorithm>
#include <vector>
using namespace std;

struct Combin {
    int a, b, c, sum;
};

bool comp(Combin a, Combin b) {
    return a.sum>b.sum;
}

int main() {
    vector<int> act;
    int n;
    while(scanf("%d", &n)==1 && n) {
        act.push_back(n);
    }

    vector<Combin>combs;

    for (int i=0; i<act.size(); i++) {
        if (i>0 && act[i-1]==act[i]) continue;
        for (int j=i+1; j<act.size(); j++) {
            if (j>i+1 && act[j-1]==act[j]) continue;
            for (int k=j+1; k<act.size(); k++) {
                if (k>j+1 && act[k-1]==act[k]) continue;
                    Combin comb;
                    comb.a=i; comb.b=j; comb.c=k;
                    comb.sum = act[i]+act[j]+act[k];
                    combs.push_back(comb);
            }
        }
    }

    sort(combs.begin(), combs.end(), comp);

    for (int i=0; i<combs.size(); i++) {
        printf("(%d,%d,%d)=%d\n", act[combs[i].a], act[combs[i].b], act[combs[i].c], combs[i].sum);
    }

    return 0;
}

Answer 4

我记得 Python 的组合生成器倾向于保持其输入的 LHS-to-RHS 从最小到最大变化，并首先输出 LHS 项。

如果你使用 Pythons 生成组合的方法，它的docs 状态如下：

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = range(r)
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

然后你可以给你的物品按重量递减顺序的功能来生成按重量递减的物品：

for x in combinations('abcdef', 3): 
    print(x)

('a', 'b', 'c')
('a', 'b', 'd')
('a', 'b', 'e')
('a', 'b', 'f')
('a', 'c', 'd')
('a', 'c', 'e')
('a', 'c', 'f')
('a', 'd', 'e')
('a', 'd', 'f')
('a', 'e', 'f')
('b', 'c', 'd')
('b', 'c', 'e')
('b', 'c', 'f')
('b', 'd', 'e')
('b', 'd', 'f')
('b', 'e', 'f')
('c', 'd', 'e')
('c', 'd', 'f')
('c', 'e', 'f')
('d', 'e', 'f')

注意：正如 Essam 在 cmets 中指出的，combinations(data, 3) 等价于 comb3(data) 其中：

def comb3(data):
    lendata = len(data)
    for i in range(lendata):
        for j in range(i+1, lendata):
            for k in range(j+1, lendata):
                yield (data[i], data[j], data[k])

Answer 5

我的其他答案只是按特定顺序使用生成的组合并没有给出完全排序的答案。事实上，他们将是 35 次中的 6 次，其中下一个三倍的总数上升而不是下降。

如果我们使用这些组合但将它们放在一个固定最大大小的堆中，那么我们可以用最大堆大小来换取排序的准确性，如下所示：

from itertools import combinations
from heapq import heappush, heappop, heappushpop

BESTOFLAST = 10     # max heap size

item2points = dict(a=9, b=9, c=8, d=6, e=6, f=5, g=4)

def partially_ordered_triples(item2points, BESTOFLAST=BESTOFLAST):
    ordereditems = sorted(item2points.keys(), 
                        key=lambda item: item2points[item],
                        reverse=True)
    #print(ordereditems)    # ['a', 'b', 'c', 'e', 'd', 'f', 'g']

    triples = combinations(ordereditems, 3)

    heap = []   # Empty heap

    # Preload heap
    for i in range(BESTOFLAST):
        triple = triples.next()
        total = sum(item2points[item] for item in triple)
        heappush(heap, (-total, triple))    # minheap so -total

    # load/remove from heap in partially sorted order    
    for triple in triples:
        total = sum(item2points[item] for item in triple)
        thistotal, thistriple = heappushpop(heap, (-total, triple))
        yield thistriple, -thistotal

    # drain rest of heap
    while heap:
        thistotal, thistriple = heappop(heap)
        yield thistriple, -thistotal

if __name__ == '__main__':
    for heapsize in range(BESTOFLAST + 1):
        print('Using a heap of size: %i and skipping:' % heapsize)
        length = skipped = 0
        previoustotal = sum(item2points.values())   # Starting high value
        for triple, newtotal in partially_ordered_triples(item2points, heapsize):
            if newtotal > previoustotal: skipped += 1
            length += 1
            previoustotal = newtotal

        print(" of %i triples, %i were skipped to keep the total count decreasing" % (length, skipped))

如果堆的大小足够大，那么就不会偏离所需的顺序。如果太小，则偏差的数量会增加：

输出：

Using a heap of size: 0 and skipping:
 of 35 triples, 6 were skipped to keep the total count decreasing
Using a heap of size: 1 and skipping:
 of 35 triples, 4 were skipped to keep the total count decreasing
Using a heap of size: 2 and skipping:
 of 35 triples, 4 were skipped to keep the total count decreasing
Using a heap of size: 3 and skipping:
 of 35 triples, 3 were skipped to keep the total count decreasing
Using a heap of size: 4 and skipping:
 of 35 triples, 2 were skipped to keep the total count decreasing
Using a heap of size: 5 and skipping:
 of 35 triples, 2 were skipped to keep the total count decreasing
Using a heap of size: 6 and skipping:
 of 35 triples, 1 were skipped to keep the total count decreasing
Using a heap of size: 7 and skipping:
 of 35 triples, 1 were skipped to keep the total count decreasing
Using a heap of size: 8 and skipping:
 of 35 triples, 1 were skipped to keep the total count decreasing
Using a heap of size: 9 and skipping:
 of 35 triples, 0 were skipped to keep the total count decreasing
Using a heap of size: 10 and skipping:
 of 35 triples, 0 were skipped to keep the total count decreasing