[USACO10NOV]购买饲料Buying Feed 单调队列优化DP

题目描述

约翰开车来到镇上，他要带 KKK 吨饲料回家。运送饲料是需要花钱的，如果他的车上有 XXX 吨饲料，每公里就要花费 X2X^2X2 元，开车D公里就需要 D×X2D\times X^2D×X2 元。约翰可以从 NNN 家商店购买饲料，所有商店都在一个坐标轴上，第 iii 家店的位置是 XiX_iXi​ ，饲料的售价为每吨 CiC_iCi​ 元，库存为 FiF_iFi​ 。

约翰从坐标 X=0X=0X=0 开始沿坐标轴正方向前进，他家在坐标 X=EX=EX=E 上。为了带 KKK 吨饲料回家，约翰最少的花费是多少呢？假设所有商店的库存之和不会少于 KKK 。

举个例子，假设有三家商店，情况如下所示：

坐标	X=1X=1X=1	X=3X=3X=3	X=4X=4X=4	E=5E=5E=5
库存	111	111	111
售价	111	222	222

如果 K=2K=2K=2 ，约翰的最优选择是在离家较近的两家商店购买饲料，则花在路上的钱是 1+4=51+4=51+4=5 ，花在商店的钱是 2+2=42+2=42+2=4 ，共需要 999 元。

输入输出格式

输入格式：

第 111 行:三个整数 K,E,NK,E,NK,E,N 第 2..N+12..N+12..N+1 行:第 i+1i+1i+1 行的三个整数代表, Xi,Fi,CiX_i,F_i,C_iXi​,Fi​,Ci​ .

输出格式：

一个整数,代表最小花费

输入输出样例

输入样例#1：

2 5 3
3 1 2
4 1 2
1 1 1

输出样例#1：

9

提交地址：Luogu4544；

我们发现， 最优的情况肯定是从家里往前走，走到要到达想要到的最远的商店， 往回走的时候再买东西；
这就提示我们， 我们要先对坐标排序， 然后设dp[i][j],表示到了第i个商店， 在第i个商店之前买了j个东西的最小花费；
dp[i][j]=min(dp[i-1][p]+dis[i]*j*j+w[i-1]*(j-p));
什么意思呢?
我们枚举一个p， 表示第i-1个商店时有p个货物，那么显然在i-1个商店买了(j-p)个货物，算上在第i-1个商店的花费，加上从i-1到i的路费，就是dp[i][j]；
复杂度nk^2， 妥妥的炸；
考虑优化；
发现转移式子里有min，自觉地想到了单调队列；
我们对式子进行一波变形。
dp[i-1][p] - w[i-1]*p + dis[i]*j*j + w[i-1]*j;
我们发现， 在i和j变化的时候，只有p是在变的，所以我们单调队列里放p；
怎么处理呢？
如果(j-q.front() > F[i-1])就pop掉队首， 因为我们要在i-1商店买的货物大于了第i-1个店的库存；
如果o=q.back(), dp[i-1][o]-w[i-1]*o >= dp[i-1][j]-w[i-1]*j, 就pop掉队尾；显然；
(写反了这个↑还能A， 数据太水了)
要注意的是，要把自己的家也当成一个点，这样dp[n][k]才是最后的答案！
然后注意开long long；
Code:

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;
 #define int long long

 inline int read()
 {
     int res=;bool fl=;char ch=getchar();
     while(!isdigit(ch)){if(ch=='-')fl=;ch=getchar();
     }while(isdigit(ch)){res=(res<<)+(res<<)+(ch-'');ch=getchar();
     }return fl?-res:res;
 }

 int n, k, e;

 struct date
 {
     int pos;
     int F;
     int w;
     friend bool operator <(date a, date b)
     {
         return a.pos < b.pos;
     }
 }fam[];

 int dp[][];

 signed main()
 {
     k = read(), e = read(), n = read();

     for (register int i =  ; i <= n ; i ++)
     {
         fam[i].pos = read(), fam[i].F = read(), fam[i].w = read();
     }

     fam[++n] = (date){e, , };

     sort(fam + , fam +  + n);

     memset(dp, 0x3f, sizeof dp);

     dp[][] = ;

     for (register int i =  ; i <= n ; i ++)
     {
         deque <int> q;
         for (register int j =  ; j <= k ; j ++)
         {
             while (!q.empty() and j - q.front() > fam[i-].F) q.pop_front(); //要买的大于上一个店的存储
             if (dp[i-][j] != 0x3f3f3f3f)
             {
                 while (!q.empty() and dp[i-][q.back()] - fam[i-].w * q.back() >= dp[i-][j] - fam[i-].w * j) q.pop_back();
                 q.push_back(j);
             }
             int o = q.front();
             if (!q.empty()) dp[i][j] = dp[i-][o] - fam[i-].w * o + (fam[i].pos - fam[i-].pos) * j * j + fam[i-].w * j;
         }
     }

     cout << dp[n][k] << endl;
     return ;

 }