USACO Mixing Milk 解题日志

先放上题目：

Mixing Milk

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.

PROGRAM NAME: milk

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 msut pay for one day's milk.

SAMPLE OUTPUT (file milk.out)

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

这里我们用到的方法，是在这道题前面的TEXT里提到的贪婪法（greedy algorithm）。

为什么会想到用贪婪法呢？当然不能因为前面刚介绍了贪婪法，所以这道题就要使用它（虽然可能作者就是这样想的）。

我们观察题目中的sample，其中，单价比较少的是买了全部，单价比较高的没有全买。

我们可以想象，为了省钱，我们会先从最便宜的买起，若牛奶还不够，再买第二便宜的……依次下去，直到买够所需要的牛奶。

这种算法的正确性，是显然的吧。虽然这样说不严谨，但是我还是不证明了。

然后问题就是，如何确定第2，第3，第4……便宜的呢？一开始我想到先排序，但是把单价排序后，怎么和原来的该单价的农民所有的牛奶数对应起来呢？也许可以用结构体完成，但是我现在对结构体了解不深刻，还不知道怎么弄。于是就想了一种方法。在第一次扫描找出最便宜的后，把这个价格改成0；第二次扫描，找出最小的且不等于0的；……依次下去，知道买够了牛奶。但是在某个数据那里错了，原来还有农民单价是0！我了个大槽！！！！！于是把价格改成-1，以后的扫描中，找出最小的且不等于-1 的。

这种方法，会比用结构体排序后用时长，不过好歹没超时。

下面贴上我的代码：

#include<fstream>
#include<algorithm>
using namespace std;

ifstream fin("milk.in");
ofstream fout("milk.out");
int total = 0;
int price[5000];
int each[5000];

int cost(int N, int M)
{
while (N > 0){
int curCheapest = 9999;
int position;
for (int i = 0; i < M; ++i){
if (price[i] < curCheapest && price[i] != -1){
curCheapest = price[i];
position = i;
}
}
price[position] = -1;
if (N - each[position] >= 0){
total += curCheapest * each[position];
N -= each[position];
}
else {
total += curCheapest * N;
N = 0;
}
}

return total;
}

int main()
{
int N, M;
fin >> N >> M;

for (int i = 0; i < M; ++i)
fin >> price[i] >> each[i];

fout << cost(N, M) << endl;

fin.close();
fout.close();

return 0;
}