This is a explanation of this problem from USACO's training website. I have converted it to markdown. Please do not just copy code; you will not learn anything; at least type it out and understand so you can do it yourself in the future!

The Merry Milk Makers company buys milk from farmers, packages it into attractive 1- and 2-Unit bottles, and then sells that milk to grocery stores so we can each start our day with delicious cereal and milk.

Since milk packaging is such a difficult business in which to make money, it is important to keep the costs as low as possible. Help Merry Milk Makers purchase the farmers’ milk in the cheapest possible manner. The MMM company has an extraordinarily talented marketing department and knows precisely how much milk they need each day to package for their customers.

The company has contracts with several farmers from whom they may purchase milk, and each farmer has a (potentially) different price at which they sell milk to the packing plant. Of course, a herd of cows can only produce so much milk each day, so the farmers already know how much milk they will have available.

Each day, Merry Milk Makers can purchase an integer number of units of milk from each farmer, a number that is always less than or equal to the farmer’s limit (and might be the entire production from that farmer, none of the production, or any integer in between).

Given:

• The Merry Milk Makers’ daily requirement of milk
• The cost per unit for milk from each farmer
• The amount of milk available from each farmer

calculate the minimum amount of money that Merry Milk Makers must spend to meet their daily need for milk.

Note: The total milk produced per day by the farmers will always be sufficient to meet the demands of the Merry Milk Makers even if the prices are high.

### INPUT FORMAT

 Line 1: Two integers, N and M. The first value, N, (0 <= N <= 2,000,000) is the amount of milk that Merry Milk Makers wants per day. The second, M, (0 <= M <= 5,000) is the number of farmers that they may buy from. Lines 2 through M+1: The next M lines each contain two integers: Pi and Ai. Pi (0 <= Pi <= 1,000) is price in cents that farmer i charges. Ai (0 <= Ai <= 2,000,000) is the amount of milk that farmer i can sell to Merry Milk Makers per day.

### SAMPLE INPUT (file milk.in)

100 5 5 20 9 40 3 10 8 80 6 30

### INPUT EXPLANATION

100 5 – MMM wants 100 units of milk from 5 farmers
5 20 – Farmer 1 says, “I can sell you 20 units at 5 cents per unit”
9 40 etc.
3 10 – Farmer 3 says, “I can sell you 10 units at 3 cents per unit”
8 80 etc.
6 30 – Farmer 5 says, “I can sell you 30 units at 6 cents per unit”

### OUTPUT FORMAT

A single line with a single integer that is the minimum cost that Merry Milk Makers must pay for one day’s milk.

630

### OUTPUT EXPLANATION

Here’s how the MMM company spent only 630 cents to purchase 100 units of milk:

Price per unit Units available Units bought Price * # units Total cost Notes
5 20 20 5*20 100
9 40 0     Bought no milk from farmer 2
3 10 10 3*10 30
8 80 40 8*40 320 Did not buy all 80 units!
6 30 30 6*30 180
Total 180 100   630 Cheapest total cost

Java

C++

Pascal

## ANALYSIS

Russ Cox

Since we’re acquiring things that are all of the same size (in this case, units of milk), a greedy solution will suffice: we sort the farmers by price, and then buy milk from the farmers with the lowest prices, always completely exhausting one farmer’s supply before moving on to the next one.

To do this, we read the input into Farmer structures, sort the array by price, and then walk the array, buying milk until we’ve got all the milk we want.

``````#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define MAXFARMER 5000

typedef struct Farmer Farmer;
struct Farmer {
int p;	/* price per gallon */
int a;	/* amount to sell */
};

int
farmcmp(const void *va, const void *vb)
{
return ((Farmer*)va)->p - ((Farmer*)vb)->p;
}

int nfarmer;
Farmer farmer[MAXFARMER];

void
main(void)
{
FILE *fin, *fout;
int i, n, a, p;

fin = fopen("milk.in", "r");
fout = fopen("milk.out", "w");

assert(fin != NULL && fout != NULL);

fscanf(fin, "%d %d", &n, &nfarmer);
for(i=0; i<nfarmer; i++)
fscanf(fin, "%d %d", &farmer[i].p, &farmer[i].a);

qsort(farmer, nfarmer, sizeof(farmer), farmcmp);

p = 0;
for(i=0; i<nfarmer && n > 0; i++) {
/* take as much as possible from farmer[i], up to amount n */
a = farmer[i].a;
if(a > n)
a = n;
p += a*farmer[i].p;
n -= a;
}

fprintf(fout, "%d\n", p);
exit(0);
}
``````

Ran Pang

Here is a program that solves the problem in linear time (with respect to the maximum price, and number of farmers, since we have to read in the data anyway), while I think the qsort used by the solution would consume O(n log n), where n is the number of farmers.

``````#include<stdio.h>

#define MAXPRICE 1001

int amount_for_price[MAXPRICE]={0};
int N, M;

int Cal(void);

int main(void) {
Cal();
return 0;
}

int Cal(void) {
int i;
int price_total=0;
int milk_total=0;
for(i=0;i<MAXPRICE;i++) {
if(amount_for_price[i]) {
if(milk_total+amount_for_price[i]<N) {
price_total+=(i*amount_for_price[i]);
milk_total+=amount_for_price[i];
}
else {
int amount_needed = N-milk_total;
price_total+=(i*amount_needed);
break;
}
}
}
{
FILE* out=fopen("milk.out","w");
fprintf(out,"%d\n",price_total);
fclose(out);
}
return 0;
}

FILE* in = fopen("milk.in","r");
int i, price, amount;
fscanf(in,"%d %d",&N,&M);
for(i=0;i<M;i++) {
fscanf(in, "%d %d", &(price), &(amount));
amount_for_price[price]+=amount;
}
fclose(in);
return 0;
}
``````

It is unnecessary to sort the prices with quicksort in O(n.lg.n) time, because there is an upper limit of the a single price (\$1000) and we know that all prices are integral. We can sort this array with count sort. We establish a ‘box’ for each of the available prices (0..1000). We save the input to an array. Then we iterate through each farmer and we memoize his index in the (0..1000) array on index equivalent to the price he offers us. Hence there can be more farmers offering the same price we put them in a linked list. Finally we iterate the array from 0 to 1000 andpick the farmers’ indexes from the linked lists. It’s pretty easy to implement, and the time complexity is O(n).

``````program milk;

type pList = ^List;
List = record
farmer:longint;
next:pList;
end;
tail:pList;
end;

var fIn,fOut:text;
sofar,i,x,want,cnt,a,b:longint;
sorted,cost,amount:array[1..5010] of longint;

t:pList;

begin
assign(fIn,'milk.in');reset(fIn);
assign(fOut,'milk.out'); rewrite(fOut);

for i:=1 to cnt do readln(fIn,cost[i],amount[i]);

for i:=0 to 1000 do begin
end;

{Cast indexes into the array}
for i:=1 to cnt do begin

t:=csort[cost[i]].tail;
if t^.farmer = -1 then t^.farmer:=i;
new(t^.next);
t^.next^.farmer:=-1;
csort[cost[i]].tail:=t^.next;
end;

{Pick indexes}
x:=1;
for i:=0 to 1000 do begin
while t^.farmer > 0 do begin
sorted[x]:=t^.farmer;
inc(x);
t:=t^.next;
end;
end;

sofar:=0;
for i:=1 to cnt do begin
if want < amount[sorted[i]] then begin
inc(sofar,want*cost[sorted[i]]);
want:=0; break;
end

else inc(sofar,amount[sorted[i]]*cost[sorted[i]]);
dec(want,amount[sorted[i]]);
end;

writeln(fOut,sofar);
close(fOut);
end.
``````

Dwayne Crooks

Do we really need the linked list that SVK’s Adam Okruhlica uses in his solution? I don’t think so. Here is a better solution that uses essentially the same idea as Adam’s solution but does away with the linked list. Takes O(max(MAXP,M)) time, where MAXP=1000 and M<=5000 is the input size. Editors note: Dwayne should be using long long integers (64 bit) instead of int’s in order to avoid overflow.

``````#include <iostream>
#include <fstream>

#define MAXP 1000

using namespace std;

int main() {
ifstream in("milk.in");
ofstream out("milk.out");

int N, M;
int P[MAXP+1];

in >> N >> M;
for (int i = 0; i <= MAXP; i++) P[i]=0;
for (int i = 0; i < M; i++) {
int price, amt;
in >> price >> amt;

// we can add amounts that cost the same price
// since x gallons costing c cents and
//          y gollons costing c cents
// is the same as
//      x+y gallons costing c cents
P[price] += amt;
}

// greedy choice: take as much of the item that
// has the least price per gallon
int res = 0;
for (int p = 0; p<=MAXP && N>0; p++) {
if (P[p]>0) {
res+=p*(N<P[p]?N:P[p]);
N-=P[p];
}
}
out << res << endl;

in.close();
out.close();

return 0;
}
``````

As the final word, Bulgaria’s Miroslav Paskov has distilled all the best ideas into a simple solution:

``````#include <fstream>
#define MAXPRICE 1001
using namespace std;

int main() {
ifstream fin ("milk.in");
ofstream fout ("milk.out");
unsigned int i, needed, price, paid, farmers, amount, milk[MAXPRICE];
paid = 0;
fin>>needed>>farmers;
for(i = 0;i<farmers;i++){
fin>>price>>amount;
milk[price] += amount;
}
for(i = 0; i<MAXPRICE && needed;i++){
if(needed >= milk[i]) {
needed -= milk[i];
paid += milk[i] * i;
} else if(milk[i] > 0) {
paid += i*needed;
needed = 0;
}
}
fout << paid << endl;
return 0;
}
``````