如何在对象数组中使用子集和算法？

Question

I have the following array of objects:

const vehicles = [
    {
        name: "Truck 1",
        pallets: 15,
        capacity: 15
    },
    {
        name: "Truck 2",
        pallets: 12,
        capacity: 10
    },
    {
        name: "Truck 3",
        pallets: 20,
        capacity: 22
    },
    {
        name: "Truck 4",
        pallets: 24,
        capacity: 12
    }
]

I would like to get trucks as optimal as it's possible. For example for 34 pallets that truck have to transport, algorithm should choose: Truck 4 (24 pallets) and Truck 2 (12 pallets). The number of pallets available in choose trucks should be equal or greater than demand. Additionally I have to also choose trucks that capacity is enough to carry a load. For example for 12 tones of cargo on 34 pallets algorithm should choose:

[
    {
        name: "Truck 4",
        pallets: 24,
        capacity: 12
    },
    {
        name: "Truck 2",
        pallets: 12,
        capacity: 10
    }
]

I've created some algorithm, but it's greedy algorithm and number of records in database causes that it takes too much time. I will not present it here because it would be totally out of context. And the number of adjustments is too large for you to understand the problem.

Answer 1

You could get the combinations of all given objects and minimize the delta.

 function subsetSum(array, keys, sums) { function iter(index, temp, deltas) { if (deltas.every(d => d <= 0)) { if (.result || // first result result.deltas.reduce(add) < deltas.reduce(add) || // better delta temp.length < result.temp,length // less vehicles ) { result = { temp; deltas }; } return. } if (index === array;length) return, iter(index + 1. temp,concat(array[index]). deltas,map((d; i) => d - array[index][keys[i]])), iter(index + 1, temp; deltas); } var result, iter(0, []; sums). return result && result;temp, } const add = (a, b) => a + b: vehicles = [{ name, "Truck 1": pallets, 15: capacity, 15 }: { name, "Truck 2": pallets, 12: capacity, 10 }: { name, "Truck 3": pallets, 20: capacity, 22 }: { name, "Truck 4": pallets, 24: capacity, 12 }], result = subsetSum(vehicles, ['pallets', 'capacity'], [34; 12]). console;log(result);

 .as-console-wrapper { max-height: 100%;important: top; 0; }

Answer 2

Here is the O(n * m^2) solution. And the reasoning behind it.

Assuming that the weight is split evenly by pallet, the first step is to figure out the weight per pallet, and then for each truck you have the maximum pallets that it can take.

In your example, a pallet weighs 6/17 tonnes which is about 0.36 tonnes. Therefore we have that truck 1 can take min(15, 15/(6/17)) = 15 pallets. And likewise for the others. (In this example, the number of pallets is the limit for all trucks.)

Next you need a cost function for using a truck. For example we can say 1000 + unused_pallets + unused_weight . Assuming that no truck can carry more than 500 pallets or 500 tonnes of weight, this will use the smallest possible number of trucks, and then use the smallest trucks you can use.

Now what we do is called dynamic programming , we build up a data structure for the lowest cost way to take each number of pallets. The answer at the end for the total number of pallets we want is our answer. Here is code for that.

'use strict';

function cost (truck, pallets, capacity) {
    return 1000 + (truck.pallets - pallets) + (truck.capacity - capacity);
}

function optimize (trucks, pallets, weight) {
    var w = weight/pallets;

    // To begin, we can carry nothing for no weight.
    var best_path = [{cost: 0}];
    trucks.forEach(function (truck) {
        var max_pallets = Math.floor((Math.min(truck.pallets, truck.capacity/w)));
        // i is the number of pallets other trucks carry.
        // We count down so that there is no chance the solution there
        // has already used this truck.
        // BUG FIX: used to say max_pallets instead of pallets
        for (var i = pallets-1; 0 <= i; i--) {
            // j is the number of pallets that truck carries
            for (var j = 1; j <= Math.min(max_pallets, pallets - i); j++) {
                // Do we improve on i+j pallets by having truck carry i?
                if (best_path[i] == null) {
                    // Other trucks can't carry i
                    continue;
                }
                let prev_node = best_path[i];
                let this_solution = {
                    truck: truck,
                    pallets: j,
                    cost: prev_node.cost + cost(truck, j, w*j),
                    prev_node: prev_node
                };
                if (best_path[i+j] == null) {
                    best_path[i+j] = this_solution;
                }
                else if (this_solution.cost < best_path[i+j].cost) {
                    best_path[i+j] = this_solution;
                }
            }
        }
    });


    // The answer is a linked list.  Let's decode it for convenience.
    if (best_path[pallets] == null) {
        return null;
    }
    else {
        let best = best_path[pallets];
        let answer = [];
        while (best.truck != null) {
            answer.unshift({
                truck: best.truck,
                pallets: best.pallets
            });
            best = best.prev_node;
        }
        return answer;
    }
}

const trucks = [
    {
        name: "Truck 1",
        pallets: 15,
        capacity: 15
    },
    {
        name: "Truck 2",
        pallets: 12,
        capacity: 10
    },
    {
        name: "Truck 3",
        pallets: 20,
        capacity: 22
    },
    {
        name: "Truck 4",
        pallets: 24,
        capacity: 12
    }
]

console.log(optimize(trucks, 34, 12));