poj 3612

//先贴代码：
#include<iostream>
#include<cstdio>
#include<string.h>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn = 100005;
const int maxh = 101;
const int inf = 0x7fffffff;
int h[maxn];
int n, c;
int dp[2][maxh];
int DP(){
	int t = 0;
	for(int i = h[1]; i < maxh; ++i){
		dp[t][i] = pow(i - h[1],2);
	}
	for(int i = 2; i <= n; ++i){ //enumerate i
		int mk[maxh],ak[maxh];
		for(int k = 0; k < maxh; ++k){
			dp[1-t][k] = inf;
			mk[k] = dp[t][k] == inf ? inf:(dp[t][k] - c * k);
			ak[k] = dp[t][k] == inf ? inf:(dp[t][k] + c * k);
		}
		int mmin = inf, amin = inf;
		int minrec[maxh], addrec[maxh];
		for(int j = 0; j < maxh; ++j){
			minrec[j] = j == 0 ? 0 : (mk[j] < mk[minrec[j - 1]] ? j: minrec[j-1]);
			addrec[maxh - j - 1] = (j == 0) ? (maxh - 1) : ((ak[maxh - j - 1] < ak[addrec[maxh - j]]) ? (maxh - j - 1): addrec[maxh - j]);
		}
		for(int j = h[i-1]; j < maxh; ++j){
			mmin = mk[minrec[j]];
			amin = ak[addrec[j]];
			int sub = pow(j - h[i],2);
			dp[1-t][j] = min(mmin + c * j + sub,amin - c * j + sub);
		}
		amin = ak[addrec[h[i-1]]];
		for(int j = h[i]; j < h[i-1]; ++j){
			dp[1-t][j] = min(dp[1-t][j],amin - c * j +((int)pow(j - h[i],2)));
		}
		for(int j = 0; j < h[i]; ++j){
			dp[1-t][j] = inf;
		}
		t = 1 - t;
	}
	return 0;
}

int main(){
	while(scanf("%d%d",&n, &c)!=EOF){
		for(int i = 1; i <= n; ++i){
			scanf("%d", h + i);
		}
		for(int i = 0; i < 2; ++i){
			for(int j = 0; j < maxh; ++j){
				dp[i][j] = inf;
			}
		}
		DP();

		int mincost = 0x7fffffff;
		int choic = n & 1;
		choic = 1 - choic;
		for(int i = h[n]; i < maxh; ++i){
			mincost = min(mincost, dp[choic][i]);
		}
		printf("%d\n", mincost);
	}
	return 0;
}

题意：给一个杆子的高度的数组h[1] ... h[n], 在相邻两个杆子(首尾的杆子不看作相邻）之间布线，单位高度差的费用为c；布线前可以选择将杆子的高度提高，提高x单位高度时，费用为x * x;

求在这n个杆子之间布线后的最小费用

思路：动态规划

dp[i][j] 表示第i根杆子的高度为j是，前i根杆子的最小费用和，那么状态转移方程为

dp[i][j] = min{dp[i-1][k] + c * |j -k| + pow(j - h[i],2)}

j,k的枚举范围是100，i有100000个， 复杂度太高，仔细观察可以发现

dp[i][j] = min{ dp[i-1][k] - c * k + c * j + pow(j - h[i],2) a[i-1]<= k <= j

dp[i-1][k] + c * k - c * j + pow(j - h[i],2) j <= k <= 100 }

这样，就可以分别用minrec和addrec两个数组纪录从0到j里使得dp[i-1][k]-c*k最小和从j到100里使得d[i-1][k] + c *k最小的k（这个纪录的时间是O(maxh)的，而不是对每个j 都枚举k)

优化：1. 对每个杆子，枚举高度时的上限可以是输入数组中的最大值而不是100

2. minrec和addrec直接纪录和j相关的最优值而不是产生最优值的下标