洛谷 P4544 [USACO10NOV]Buying Feed G）(单调队列优化DP)

题目链接：P4544 [USACO10NOV]Buying Feed G

建议做这题前先做下这题P1886 滑动窗口 /【模板】单调队列

我们可以用dp[i][j]表示当前走到前i个点，已经买了j吨饲料时到达下一个点的最小花费，可以推出状态转移方程方程dp[i][j]=min(dp[i][j],dp[i-1][k]+d*j^2+c*(j-k)),0<=k<=j（d为当前点到下一点的距离）,,实际是dp[i][j]就是在所有满足条件的k中查找最小的一个dp[i-1][k]+d*j^2+c*(j-k)，整理下该式子，得到：(dp[i-1][k]-c*k)+(d*j^2+c*j),这时我们可以发现该式子后半部分对于每个j为定值，与k无关，此时我们只需要查找小于k的所有数中(dp[i-1][k]-c*k)值最小且j-k<=fi(即当前商店买的饲料不能超出上限)的作为转移点即可，我们可以把(dp[i-1][k]-c*k)作为值，用单调队列维护，枚举j时每次把不合法队头的踢出去，把不如当前点更优的队尾也踢出去，放入当前点对应的(dp[i-1][k]-c*k)，这样就使得队列中按(dp[i-1][k]-c*k)升序，每次队头即为花费最小的转移情况   

具体注释和细节见代码：

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll INF=1e18;
const ll N=2e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll c,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=c;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	chile(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
		b/=2;
	}
	return res;
}
ll fac[MAXN+10],inv[MAXN+10]
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m-n]%mod)%mod;
}
fac[0]=1;inv[0]=1;
for(ll i=1;i<=MAXN;i++){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
	set<int>::iterator it=st.begin();
*/
//emplace_back()  等于push_back(),但效率更高,传输pair时emplace_back(i,j)==push_back({i,j}) 
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
  //emplace_back() 
struct elemt{
	ll x,f,c;
	bool operator<(const elemt v){
		return x<v.x;//按坐标升序
	}
};//把商店定义为结构体，方便排序
//(x+d)^2=x^2+2xd+d^2;
ll dp[510][10010];//当前在第i个商店，已经有j吨饲料的花费
elemt a[510];
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
ll k,e,n;
cin>>k>>e>>n;
for(int i=1;i<=n;i++){
	cin>>a[i].x>>a[i].f>>a[i].c;
}
sort(a+1,a+n+1);//按坐标升序排序
a[n+1].x=e;
memset(dp,inf,sizeof(dp));
deque<pair<ll,ll>>q;//开两维分别维护dp[i-1][j]-a[i].c*j和k,队列内按dp[i-1][j]-a[i].c*j升序
for(int j=0;j<=a[1].f;j++){//初始化
	dp[1][j]=a[1].c*j+(a[2].x-a[1].x)*j*j;
}
for(int i=2;i<=n;i++){
	while(q.size()){
		q.pop_back();//把之前的清空
	}
	for(int j=0;j<=k;j++){
		while(q.size()&&q.back().first>=dp[i-1][j]-a[i].c*j){
			q.pop_back();//装的货物没有当前多，费用系数还比当前高（不如当前优）的可以踢出去了
		}
		q.push_back({dp[i-1][j]-a[i].c*j,j});//当前点放入队列
		while(q.size()&&q.front().second+a[i].f<j){//该商店全买完也不够j的踢出去
			q.pop_front();
		}
		dp[i][j]=min(dp[i][j],q.front().first+(a[i+1].x-a[i].x)*j*j+a[i].c*j);//最前面的就是最优的，
		//cout<<"i="<<i<<" j="<<j<<" dp="<<dp[i][j]<<" fr="<<q.front().first<<endl;
		
	}
}
//ll ans=dp[n][k]+(e-a[n].x)*k*k;//回到家的花费
cout<<dp[n][k]<<endl;
	return 0;
}