The model is a special procedure of linear programming for finding the minimum cost for distributing homogeneous units of a product from several points of supply (sources) to a number of points of demand (destinations). In terms I’m more comfortable using, that means that the model answers the question: what are the cheapest routes I can use to send a certain number of products from a certain number of suppliers to a certain number of destinations?

To answer this, of course, we need to know several things beforehand:

1. the number of sources, as well as their capacity to supply the products to distribute;
2. the number of destinations, as well as their demand; and —
3. the per-unit cost of shipping the products from a certain source to a certain destination.

This model is a linear programming model, that is, the relationships among variables is linear: transportation costs are treated as a direct linear function of the number of units shipped. That means, basically, that the more units you send somewhere, the more it’s gonna cost you. Being an LP problem, it assumes several things:

1. the items to be shipped are homogeneous, or the same (similar);
2. shipping cost per unit is the same regardless of the number of units shipped; and —
3. there is onlly one route or mode of transportation being used between each origin and each destination.

To illustrate, suppose a clothing manufacturer has three outlets, each with a known amount of demand, and three factories, their capacities also known. For simplicity’s sake, let’s call each outlet A, B, and C, and each factory W, X, and Y. Their capacities, demands, and cost to transport per unit is shown below:

First, note: total demand and total supply are equal; this is what’s called a balanced condition, and while highly unlikely in real life situations, it’s enough to demonstrate the procedure for now.

Solving a problem with so few variables by hand is relatively easy, and I’ll get into more detail about that later. There’s also a nifty tool for both Microsoft Excel and Sun Open Office Calc called solver that tackles precisely this problem, albeit with some limitations. This time around though, I’ll illustrate solving this problem using lp_solve, a free (see LGPL for the GNU lesser general public license) linear (integer) programming solver based on the revised simplex method and the Branch-and-bound method for the integers.

Why lp_solve?

Well, if I could only provide one answer for this, it’d be because it’s free. Free as in freedom. To use, alter, sell, do stuff. Fortunately, there are other answers as well: it’s robust and powerful, has an API for a lot of programming languages so you can call the results from, say, Python, and best of all, it’s very easy to use.

The process

Looking at the cost to transport per unit table, we can pretty much see that we don’t want to be sending any significant number of products from X to B, or Y to C, because they have the highest cost. Instead, we want to maximize the route from W to A, since it’s significantly cheaper. Unfortunately, W can only supply 56 units, so we’d have to get the 16 from somewhere; hopefully from Y, since it’s cheaper than X. But if we do that, we might end up sending from X to B again, which is a no-no. Trying to solve this with mentally is hard — there’s just too many things to consider. Enter linear programming.

Before we can begin, we need to look at its linear programming formulation — this is the hardest part, trust me, and since it’s a very specific case of linear programming, that means there’s really just one way to formulate it. First, consider the decision variables: three factories and three outlets, so we have (3*3) nine decision variables, which we’ll name as a combination of their names: WA, WB, WC, XA, XB, XC, YA, YB, YC. The first letter identifies the source, or factory, and the second letter identifies their destination, or outlet. Recall, our objective function, that is, what we want our function to do, would be to minimize the total transportation cost; we write it this way:

min: 4wa + 8wb + 8wc + 16xa + 24xb + 16xc + 8ya + 16yb + 24yc;

Well I’ll be darned, that looks a lot like C code, doesn’t it? And it behaves much as you’d expect: a quick look at the table graphic above and you’ll see that we’re basically adding the product of each per-unit cost to each decision variable – which just so happens to correspond to the cells on the table. Since it’d cost $4.00 to send a unit of product from W to A, we have 4wa, and so on. Nifty.

Next, we’ll look at the constraints: since each source has a maximum capacity to supply the product, and each destination has a minimum demand, we’d write that down like this:


wa + wb + wc <= 56; /* plant "W" can't ship more than 56 units */
xa + xb + xc <= 82; /* plant "X" can't ship more than 82 units */
ya + yb + yc <= 77; /* plant "Y" can't ship more than 77 units */

wa + xa + ya >= 72; /* destination "A" requires at least 72 units */
wb + xb + yb >= 102;/* destination "B" requires at least 102 units */
wc + xc + yc >= 41; /* destination "C" requires at least 41 units */

Note that the comments enclosed by /* and */ are exactly that: comments.

With that done, we have enough to solve our problem using lp_solve; simply press the F9 key. Here I’m using the lp_solve IDE, which is available for the Windows platform, but I’ve run it under WinE and ahd no problems. The results are illustrated below:

What the data is telling us here is that we can send 56 units from W to A, 41 units from X to A, another 41 units from X to C, 31 from Y to A, and 46 from Y to B. Using our objective function above, we can calculate the cost for this solution:

cost = 4*0 + 8*56 + 8*0 + 16*41 + 24*0 + 16*41 + 8*31 + 16*46 + 24*0 = 448 + 656 + 656 + 248 + 736 = 2,744

So our solution will end up costing $2,744.00, which is the minimum cost do do the transaction.