Pearls--DP

Pearls

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 8725		Accepted: 4361

Description

In Pearlania everybody is fond of pearls. One company, called The Royal Pearl, produces a lot of jewelry with pearls in it. The Royal Pearl has its name because it delivers to the royal family of Pearlania. But it also produces bracelets and necklaces for ordinary people. Of course the quality of the pearls for these people is much lower then the quality of pearls for the royal family.In Pearlania pearls are separated into 100 different quality classes. A quality class is identified by the price for one single pearl in that quality class. This price is unique for that quality class and the price is always higher then the price for a pearl in a lower quality class. 
Every month the stock manager of The Royal Pearl prepares a list with the number of pearls needed in each quality class. The pearls are bought on the local pearl market. Each quality class has its own price per pearl, but for every complete deal in a certain quality class one has to pay an extra amount of money equal to ten pearls in that class. This is to prevent tourists from buying just one pearl. 
Also The Royal Pearl is suffering from the slow-down of the global economy. Therefore the company needs to be more efficient. The CFO (chief financial officer) has discovered that he can sometimes save money by buying pearls in a higher quality class than is actually needed.No customer will blame The Royal Pearl for putting better pearls in the bracelets, as long as the 
prices remain the same. 
For example 5 pearls are needed in the 10 Euro category and 100 pearls are needed in the 20 Euro category. That will normally cost: (5+10)*10+(100+10)*20 = 2350 Euro.Buying all 105 pearls in the 20 Euro category only costs: (5+100+10)*20 = 2300 Euro. 
The problem is that it requires a lot of computing work before the CFO knows how many pearls can best be bought in a higher quality class. You are asked to help The Royal Pearl with a computer program. 

Given a list with the number of pearls and the price per pearl in different quality classes, give the lowest possible price needed to buy everything on the list. Pearls can be bought in the requested,or in a higher quality class, but not in a lower one. 

Input

The first line of the input contains the number of test cases. Each test case starts with a line containing the number of categories c (1<=c<=100). Then, c lines follow, each with two numbers ai and pi. The first of these numbers is the number of pearls ai needed in a class (1 <= ai <= 1000). 
The second number is the price per pearl pi in that class (1 <= pi <= 1000). The qualities of the classes (and so the prices) are given in ascending order. All numbers in the input are integers. 

Output

For each test case a single line containing a single number: the lowest possible price needed to buy everything on the list. 

Sample Input

2
2
100 1
100 2
3
1 10
1 11
100 12

Sample Output

330
1344

题目链接：http://poj.org/problem?id=1260

   哎，这个题我看得题解，上来就看英文然后并没有看懂，TAT，果然我是属于那种读题就能读5个小时的人啊，然后就去了谷歌翻译，然后并不能理解题意，题目中给出的那个示例也并没有看懂。。尴尬。。然后去搜了题解，好吧，懂了，然后自己敲了一遍，竟然一遍就过了。。这是万万没有想到的，我决定按我的理解来写一篇博客。

题意大概是说有一个皇家珠宝店，每买它一种宝石要付出比自己要的数量多10颗的价格，但可以按照等级高的宝石的价格算到等级高的宝石的数量里面一起买，因为单买要付出多10的颗的价格，所以有时候按照高价格来买反而总价更便宜。

例如买5颗价值为10的、100颗价值为20的珠宝，有两种方案：一种为分别买两种等级的珠宝价钱为(5+10)*10+(100+10)*20 = 2350；另一种是将等级低的（即价格低）的珠宝全部换为等级高的，此时价钱为(5+100+10)*20 = 2300，故第二种方案较优。（题目中的示例）

大题思路是用两个数组，一个是dp[],一个是sum[]，dp[i]代表的是当前第i种宝石所需要的最少的价格，sum[i]代表的是前i种宝石的总数量，用a[]表示输入的数量,b[]表示输入的价格，所以初始化数组为sum[i]=sum[i-1]+a[i],dp[i]=(sum[i]+10)*b[i];就是说全部用第i种宝石的数量来买，还有一种买法，(sum[i]-sum[1]+10)*p[i]+dp[1] 即从第二个开始前面的所有珠宝用i的价值去买，或者（sum[i]-sum[2] +10）*p[i] + dp[2] 即从第三个。。。依次计算，其中最小的一个就是i的解。在此可能会有读者疑惑可不可以跳跃等级去买，这里网上有一个示例写的很好：用高一等级的代替低一等级的必须是连续代替。例如 3 5，90 7，100 12要想代替3个5价值的首先考虑用7价值的代替，因为3*7=21 （3+10）*5=65 显然比较合算，这样就不需要考虑用12价值的那个代替了，因为前面已经有了最优解，也就是说相互代替不会跳跃。这样就很明确了吧。

代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
int dp[10000];
int sum[10000];
int a[10000];
int b[10000];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,0,sizeof(dp));
        memset(sum,0,sizeof(sum));
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            int x,y;
            scanf("%d%d",&a[i],&b[i]);
            sum[i]=sum[i-1]+a[i];//初始化
            dp[i]=(sum[i]+10)*b[i];
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<i;j++)
            {
                dp[i]=min(dp[i],(sum[i]-sum[j]+10)*b[i]+dp[j]);//状态转移方程
            }
        }
        printf("%d\n",dp[n]);
    }
    return 0;
}

我就这么一敲，神奇的就AC了。

网上还有一种从后往前搜的方法，不得不说，大神就是大神，这里给出链接：

http://blog.csdn.net/qq_16255321/article/details/41292337