poj(1260,动归)

  做得最无语的一道题目。

  题目的大概意思是你的采购单上需要n多级别的宝石，然后每购买一级的宝石，需要额外支付10个该等级宝石的钱，然后可以用更高等级的宝石代替低级别的宝石。

  

  动归方程是f[i]表示前i等级所需的最低钱数为，那么动归方程是(a[i]表示第i级别需要的个数，p[i]表示第i级别宝石单价)：

  f[i] = min(f[i],  f[j] + ( a[j+1] + a[j+2] + ... + a[i] + 10 ) * p(i) );

  

  之前自己想了一个从前往后的方法，然而WA了好多次，不知道为什么不可以，查到的数据都试了，不知道什么原因。

  然后，题目一个超级坑的原因是，数据并不是按它所说的升序，因为排序之后的提交会WA。

  

#include "stdio.h"
#include "string.h"
#include "math.h"
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
using namespace std;

#define MAXM 1
#define MAXN 1005
#define max(a,b) a > b ? a : b
//#define min(a,b) a < b ? a : b
#define Mem(a,b) memset(a,b,sizeof(a))
int Mod = 1000000007;
double pi = acos(-1.0);
double eps = 1e-6;

typedef struct{
	int f,t,w,next;
}Edge;
Edge edge[MAXM];
int head[MAXN];
int kNum;

__int64 minn(__int64 a, __int64 b){
	if( a == 0 )
		return b;
	return a < b ? a : b ;
}

void addEdge(int f, int t, int w)
{
	edge[kNum].f = f;
	edge[kNum].t = t;
	edge[kNum].w = w;
	edge[kNum].next = head[f];
	head[f] = kNum ++;
}

__int64 dp[MAXN];
typedef struct{
	int num, pv;
}Node;
Node node[MAXN];

bool Comp(Node a, Node b){
	return a.pv < b.pv;
}

int T, N;

void solve(){
	Mem(dp, 0);
	for(int i = 0; i < N; i ++){
		cin>>node[i].num>>node[i].pv;
	}
	//排序提交会WA
//	sort(node, node + N, Comp);
	for(int i = 0; i < N; i ++){
		int cnt = node[i].num + 10;
		for(int j = i - 1; j >= 0; j --){
			dp[i] = minn(dp[i], dp[j] + cnt * node[i].pv);
			cnt += node[j].num;
		}
		dp[i] = minn(dp[i], cnt * node[i].pv);
	}
	printf("%I64d\n",dp[N-1]);
}


int main()
{
//	freopen("d:\\test.txt", "r", stdin);

//	while(cin>>T){
	cin>>T;
		while(T--){
			cin>>N;
			solve();
		}
//	}

	return 0;
}