Greedy algorithm to find potential weighted activities in order? - algorithm

Question

For example, let's say there's a list of activities {a, b, c, d, e, f, g}
a & b are worth 9 points each.
c is worth 8 points.
d & e are worth 6 points each.
f is worth 5 points.
g is worth 4 points.
The list of activities is already sorted by points descending.
I want to find the highest points combination of three activities (let's call this combination X) that fulfills certain requirements (such that F(X) = true).
F(X) accepts only a combination of three activities, and cannot be modified.
How can I generate X without first having to calculate all possible combinations?
How can I iterate through all the possible combinations in decreasing total points?
I want to be able to find the highest point combination, test it. If it fails, generate second-highest point combination, etc.
The example list is only a few items. However, the actual list can get extremely large that and it would be impractical to generate all combinations.
How should I do this?

Answer 1

The following idea only solves an easier version of the problem, but maybe it can be extended to a more powerful solution.
Let [a(1)..a(N)] be the input array.
What I suggest here is a way to enumerate the top N^(1/3) triplets, out of the C(N,3)~N^3 ones in the complete enumeration. I know this is modest, but it guarantees O(N) time and space.
s = a(1) + a(2) + a(N^(1/3))
T = All triplets in [a(1),a(2), .. ,a(N^(1/3))] (takes O(N) time and space)
Sort T in descending triplet sum order (Time complexity: O(N^(1/3) * log N) = O(N) )
Iterate over T and return every triplet r while sum(r) >= s
Explanation:
In (1) we compute the highest score possible for a triplet that doesn't involve only items from T = [a(1)..a(N^(1/3))]. In other words, T already contains all triplets of score > s. Therefore we generate all triplets in T, sort them, and return only the ones we are sure about (i.e. the ones with score>=s). How many such triplets will be returned? well, this depends on the array values, but we can guarantee at least N^(1/3) - 2 triplets, since all triplets [a(1)+a(2)+a(i)] for 2<i<=N^(1/3) have a sum >=s. In practice the number of "good" triplets may be much higher, but again, this depends on the array numbers distribution.

Answer 2

Here is way to generate ordered combinations of three:-
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

I do not think there is a great solution for your requirement. Here is the best (and worst) solution I can think of: Generate all combinations put them in a vector then sort! Complexity is O(n^3 log(n^3)). Only little improvement I think can be achieve by assuming that there is no point of having same value in the same position multiple times as it will generate a combination already got generated.
Implementation in 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

I remembered that Pythons combinations generator tends to keep the LHS-to-RHS of its input varying from the least-to-most, and outputs the LHS terms first.
If you use Pythons method of generating combinations, which its docs states is the following:
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)
Then you can just give the function your items in decreasing weight order to generate items in decreasing weight order:
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')
Note: As Essam points out in the comments, combinations(data, 3) is equivalent to comb3(data) where:
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

My other answer of just using generated combinations in a certain order doesn't give the fully sorted answer. In fact their will be 6 out of 35 occasions where the total for the next triple goes up rather than down.
If we use the combinations but put them in a heap of fixed maximum size then we can trade the maximum heap size for accuracy of sort like so:
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))
If the size of the heap is large enough then there will be no deviations from the required order. If too small then the number of deviations increases:
The output:
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