[斜率优化DP] codeforces 673E. Levels and Regions

题意：
要把$1～n$分成$k$组，每组内的数必须连续，组与组不相交且每个数必须属于一个组，并且任意$i$有一个参数$t_i$。
如果$[l,r]$为一组，那么从$l$走到$l+1$的概率是$\frac{t_l}{t_l}$，从$l+1$走到$l+2$的概率是$\frac{t_l}{t_{l+1}}＋\frac{t_{l+1}}{t_{l+1}}$，依次类推，从$l$要么走到$l+1$，要么原地不动，那么组$[l,r]$的费用就是从$l$走到$r$的期望次数。现在要分成$k$组，让总费用最小，每个数仅能属于一个组。
题解：
先推期望公式。
设$sum[i]=\sum_{j=1}^{i}t_i$，$rev[i]=\sum_{j=1}^{i}{1\over t_i}$，那么从$1$走到$i$的期望$exc[i]=exc[i-1]+{sum[i]\over t_i}$。
然后观察得到从$l$走到$r$的期望公式$exc[l][r]＝exc[r]-exc[l-1]-sum[l-1]*(rev[r]-rev[l-1])$。
然后设$dp[i][j]$表示以前$i$个数成$j$段的最小费用。
转移：$dp[i][j]=min(dp[l][j-1]+exc[l+1][i])$。
发现这是个$O(n^2*k)$的转移。
当我们的$i$固定的时候，就是要在$[1,i-1]$找一个最优解$l$，观察形式得出可以斜率优化，$O(n*k)$的复杂度就可以过了。
斜率优化可以看这里。
推出斜率公式为

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
double exc[N] = {0}, sum[N] = {0}, rev[N] = {0};
double t[N];
double dp[N][55];
inline double y(int x, int p){
    return dp[x][p] - exc[x] + sum[x]*rev[x];
}
inline double g(int j, int k, int p){
    return (y(j, p)-y(k, p))/(sum[j]-sum[k]);
}
inline double cal(int l, int i){
    return exc[i]-exc[l]-(rev[i]-rev[l])*sum[l];
}
int q[N], top, tail;
inline void add(int i, int k){
    while(top < tail-1 && g(i, q[tail-1], k) < g(q[tail-1], q[tail-2], k)) tail--;
    q[tail++] = i;
}
inline int getmax(int i, int k){
    while(top < tail-1 && g(q[top+1], q[top], k) < rev[i]) top++;
    return q[top];
}
int main(){
    int n, K;
    scanf("%d%d", &n, &K);
    for(int i = 1; i <= n; ++i) scanf("%lf", t+i);
    for(int i = 1; i <= n; ++i){
        sum[i] = sum[i-1] + t[i];
        rev[i] = rev[i-1] + 1.0/t[i];
        exc[i] = exc[i-1] + sum[i]/t[i];
    }
    for(int i = 1; i <= n; ++i) dp[i][1] = exc[i];
    for(int k = 2; k <= K; ++k){
        top = tail = 0;
        q[tail++] = 0;
        for(int i = 1; i <= n; ++i) add(i, k-1);
        for(int i = 1; i <= n; ++i){
            if(i >= k){
                int l = getmax(i, k-1);
                dp[i][k] = dp[l][k-1] + cal(l, i);
            }
            else dp[i][k] = 1e50; //不可能状态
        }
    }
    printf("%.10f\n", dp[n][K]);
}