GYM-101572A Airport Coffee(DP+单调队列)

题意：

一个人要从起点走到终点，距离为m,速度为A

中间有n个咖啡馆，当经过咖啡馆可以选择买咖啡，买完咖啡后需要经过T秒的冷却，冷却期间这个人的速度为A，接着花R秒喝咖啡，喝咖啡期间速度变成B（B>A），每次经过咖啡馆如果要买新咖啡就需要把原本的扔掉。

问：如果要用最短的时间到达终点，买咖啡的方案是怎样，输出任意一个方案

题解：

设dp[i]为到达第i个咖啡馆并买咖啡所需要的时间，x=a*t,y=a*t+b*r

dp[i]=min(dp[j]+cost(j,i)) j∈[1,i-1]，其中cost(j,i)表示在j个咖啡馆买完咖啡后走到i个咖啡馆所需要的时间

根据dis(j,i)，可以将1~i-1分成3段，cost可分为3种情况：

①a[i]-a[j]<=x,cost=(a[i]-a[j])/A

②x<a[i]-a[j]<=y,cost=(a[i]-a[j]-x)/B+T

③a[i]-a[j]>y,cost=(a[i]-a[j]-y)/A+T+R

根据贪心可知，第①种情况可以直接排除，只要考虑②③，②③可以分别转化为：

②cost=a[i]/B-(a[j]+x)/B+T

③cost=a[i]/A-(a[j]+y)/A+T+R

当枚举到第i个咖啡馆时，后面一部分已知，因此可以看做常数，可以考虑用线段树维护。但其实可以直接用单调队列来求解。

对情况②建一个单调队列，将dp[j]-(a[j]+x)/B+T按从小到大顺序维护，每次都将队列中dis(j,i)>y的出队，因此最优决策点就是队首。

对于情况③只要维护一下1~i-1中，满足dis(j,i)>y且使dp[j]-(a[j]+y)/A+T+R最小的j即可。

#include<bits/stdc++.h>
#define FIN freopen("in.txt","r",stdin);
#define eps 1e-10
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f;
const int MX = 5e5 + 5;

LL m, x, y, arr[MX];
int n, T, R, a, b;
int pre[MX], q[MX];
double dp[MX], f[MX], A, B;

double cal(LL ret) {
    if(ret <= x) return ret / A;
    if(ret <= y) return (ret - x) / B + T;
    return (ret - y) / A + T + R;
}

int main() {
    //FIN;
    scanf("%I64d%d%d%d%d%d", &m, &a, &b, &T, &R, &n);
    x = a * T, y = x + b * R;
    A = a, B = b;
    for(int i = 1; i <= n; i++) scanf("%I64d", &arr[i]);
    double d = 1e20, ans = m / A;
    int p = 0, s = 1, t = 0, last = 0;
    for(int i = 1, j = 1, k = 1; i <= n; i++) {
        dp[i] = arr[i] / A;
        while(j < i && arr[i] - arr[j] >= y) {
            double tmp = dp[j] - (arr[j] + y) / A + T + R;
            if(tmp < d) {
                d = tmp;
                p = j;
            }
            j++;
        }
        if(p && d + arr[i] / A < dp[i]) {
            dp[i] = d + arr[i] / A;
            pre[i] = p;
        }
        while(k < i && arr[i] - arr[k] >= x) {
            f[k] = dp[k] - (arr[k] + x) / B + T;
            while(s <= t && f[q[t]] > f[k]) t--;
            q[++t] = k++;
        }
        while(s <= t && arr[i] - arr[q[s]] > y) s++;
        if(s <= t && dp[i] > f[q[s]] + arr[i] / B) {
            dp[i] = f[q[s]] + arr[i] / B;
            pre[i] = q[s];
        }
        double tmp = cal(m - arr[i]);
        if(dp[i] + tmp < ans) {
            ans = dp[i] + tmp;
            last = i;
        }
    }
    stack<int>st;
    while(last) st.push(last), last = pre[last];
    printf("%d\n", st.size());
    while(!st.empty()) {
        printf("%d ", st.top() - 1), st.pop();
    }
    return 0;
}