Cartesian product with specific criteria

Question

I am attempting to find the cartesian product and append specific criteria.

I have four pools of 25 people each. Each person has a score and a price. Each person in each pool looks as such.

[0] => array(
    "name" => "jacob",
    "price" => 15,
    "score" => 100
),
[1] => array(
    "name" => "daniel",
    "price" => 22,
    "score" => 200
)

I want to find the best combination of people, with one person being picked from each pool. However, there is a ceiling price where no grouping can exceed a certain price.

I have been messing with cartesians and permutation functions and cannot seem to figure out how to do this. The only way I know how to code it is to have nested foreach loops, but that is incredibly taxing.

This code below, as you can see, is incredibly inefficient. Especially if the pools increase!

foreach($poolA as $vA) {
   foreach($poolb as $vB) {
       foreach($poolC as $vC) {
            foreach($poolD as $vD) {

                // calculate total price and check if valid
                // calculate total score and check if greatest
                // if so, add to $greatest array

            }
        }
    }    
}      

I also thought I could find a way to calculate the total price/score ratio and use that to my advantage, but I don't know what I'm missing.

Answer 1

As pointed out by Barmar, sorting the people in each pool allows you to halt the loops early when the total price exceeds the limit and hence reduces the number of cases you need to check. However, the asymptotic complexity for applying this improvement is still O(n⁴) (where n is the number of people in a pool).

I will outline an alternative approach with better asymptotic complexity as follow:

1. Construct a pool X that contains all pairs of people with one from pool A and the other from pool B.
2. Construct a pool Y that contains all pairs of people with one from pool C and the other from pool D.
3. Sort the pairs in pool X by total price. Then for any pairs with the same price, retain the one with the highest score and discard the remaining pairs.
4. Sort the pairs in pool Y by total price. Then for any pairs with the same price, retain the one with the highest score and discard the remaining pairs.
5. Do a loop with two pointers to check over all possible combinations that satisfy the price constraint, where the head pointer starts at the first item in pool X, and the tail pointer starts at the last item in pool Y. Sample code is given below to illustrate how this loop works:

==========================================================================

$head = 0;
$tail = sizeof($poolY) - 1;

while ($head < sizeof($poolX) && $tail >= 0) {
    $total_price = $poolX[$head].price + $poolY[$tail].price;

    // Your logic goes here...

    if ($total_price > $price_limit) {
        $tail--;
    } else if ($total_price < $price_limit) {
        $head++;
    } else {
        $head++;
        $tail--;
    }
}

for ($i = $head; $i < sizeof($poolX); $i++) {
    // Your logic goes here...
}

for ($i = $tail; $i >= 0; $i--) {
    // Your logic goes here...
}

==========================================================================

The complexity of steps 1 and 2 are O(n²), and the complexity of steps 3 and 4 can be done in O(n² log(n)) using balanced binary tree. And step 5 is essentially a linear scan over n² items, so the complexity is also O(n²). Therefore the overall complexity of this approach is O(n² log(n)).

Answer 2

A couple of things to note about your approach here. Speaking strictly from a mathematics perspective, you're calculating way more permutations than is actually necessary to arrive at a definitive answer.

In combinatorics, there are two important questions to ask in order to arrive at the exact number of permutations necessary to yield all possible combinations.

1. Does order matter? (for your case, it does not)
2. Is repetition allowed? (for your case, it is not necessary to repeat)

Since the answer to both of these question is no, you need only a fraction of the iterations you're currently doing with your nested loop. Currently you are doing, pow(25, 4) permutations, which is 390625. You only actually need n! / r! (n-r)! or gmp_fact(25) / (gmp_fact(4) * gmp_fact(25 - 4)) which is only 12650 total permutations needed.

Here's a simple example of a function that produces combinations without repetition (and where order does not matter), using a generator in PHP (taken from this SO answer).

function comb($m, $a) {
    if (!$m) {
        yield [];
        return;
    }
    if (!$a) {
        return;
    }
    $h = $a[0];
    $t = array_slice($a, 1);
    foreach(comb($m - 1, $t) as $c)
        yield array_merge([$h], $c);
    foreach(comb($m, $t) as $c)
        yield $c;
}

$a = range(1,25); // 25 people in each pool
$n = 4; // 4 pools

foreach(comb($n, $a) as $i => $c) {
    echo $i, ": ", array_sum($c), "\n";
}

It would be pretty easy to modify the generator function to check whether the sum of prices meets/exceeds the desired threshhold and only return valid results from there (i.e. abandoning early where needed).

The reason repetition and order are not important here for your use case, is because it doesn't matter whether you add $price1 + $price2 or $price2 + $price1, the result will undoubtedly be the same in both permutations. So you only need to add up each unique set once to ascertain all possible sums.

Answer 3

Similar to chiwangs solutions, you may eliminate up front every group member, where another group member in that group exists, with same or higher score for a lower price. Maybe you can eliminate many members in each group with this approach.

You may then either use this technique, to build two pairs and repeat the filtering (eliminate pairs, where anothr pair exists, with higher score for the same or lower costs) and then combine the pairs the same way, or add a member step by step (one pair, a triple, a quartett).

If there exists some member, who exceed the allowed sum price on their own, they can be eliminated up front.

If you order the 4 groups by score descending, and you find a solution abcd, where the sum price is legal, you found the optimal solution for a given set of abc.

Answer 4

The reponses here helped me figure out the best way for me to do this.

I haven't optimized the function yet, but essentially I looped through each results two at a time to find the combined salaries / scores for each combination in the two pools.

I stored the combined salary -> score combination in a new array, and if the salary already existed, I'd compare scores and remove the lower one.

$results = array();
foreach($poolA as $A) {
    foreach($poolB as $B) {
        $total_salary = $A['Salary'] + $B['Salary'];
        $total_score =  $A['Score'] + $B['Score'];
        $pids = array($A['pid'], $B['pid']);

        if(isset($results[$total_salary]) {
             if($total_score > $results[$total_salary]['Score']) {
                 $results[$total_salary]['Score'] => $total_score;
                 $results[$total_salary]['pid'] => $pids; 
        } else {
            $results[$total_salary]['Score'] = $total_score;
            $results[$total_salary]['pid'] = $pids;
        }
    }         
}

After this loop, I have another one that is identical, except my foreach loops are between $results and $poolC.

foreach($results as $R) {
    foreach($poolC as $C) {

and finally, I do it one last time for $poolD.

I am working on optimizing the code by putting all four foreach loops into one.

Thank you everyone for your help, I was able to loop through 9 lists with 25+ people in each and find the best result in an incredibly quick processing time!