首先ORZ一发Claris聚聚的题解：http://www.cnblogs.com/clrs97/p/8689215.html，不然我可能没机会补过这道神题了。
这里写一个更详细的题解吧（我还是太菜了啊）。
题目描述
有\(n(n \le10^5)\)个人依次进入一个入口，要到一个出口。入口到出口有两条同样长的路。每个人都有一个速度，用通行时间\(a_i(1\le a_i \le 10^6)\)表示，他可以选择任一条路走。但是，若走这条路的前面的人比他慢的话，他只能降到和前面所有人最慢的那个人同样的速度（从而会多花时间）。现在请规划每个人选哪条路，使得每个人因等前面的人而浪费的时间尽可能少。
Sample Input
100 4 3 2 1
Sample Output
6
详细题解
此题很容易用DP来做。考虑前\(i\)个人，则两个楼梯必有一个的通行时间变为前\(i\)个人最慢的那个，我们设\(dp[i][j]\)表示前i个人另一个楼梯当前通行时间是\(j\)（\(j\)从小到大离散化）时的最优答案，则考虑\(dp[i+1]\)和\(dp[i]\)的关系：
（1）若\(a[i+1]>=max(a[1..i])\)，则显然\(dp[i+1][j]=dp[i][j]\)；
（2）若\(a[i+1]<max(a[1..i])\)，则：
情况1：\(j\)对应状态快的那个楼梯比\(a[i+1]\)时间短，且选这个楼梯，于是\(dp[i+1][k]=min(dp[i][j],j<=k)\)，其中\(k\)为\(a[i+1]\)离散化的结果；
情况2：\(j\)对应状态快的那个楼梯比\(a[i+1]\)时间短，但选最慢的楼梯，于是\(dp[i+1][j]=dp[i][j]+max(a[1..i])-a[i+1]\)，其中\(j<k\)；
情况3：\(j\)对应状态快的那个楼梯比\(a[i+1]\)的时间长，那必然选这个楼梯，于是\(dp[i+1][j]=dp[i][j]+f[j]-a[i+1]\)，其中\(j>k\)，\(f[j]\)表示第\(j\)小的值。
这样状态数和转移复杂度均为\(n^2\)。下面考虑数据结构优化。
我们需要维护的dp要支持区间最小值查询，单点修改，区间增加，和区间\(dp[i][j]+=f[j]\)。
如果没有最后的操作此题直接用线段树就简单多了。
加上了这种操作，考虑分块。每块首先要维护增量tag，该tag对最值无影响。下面主要考虑\(dp[i][j]+=f[j]\)。
注意到一个性质：若\((dp[i][j+1]-dp[i][j])/(f[j+1]-f[j])<(dp[i][j]-dp[i][j-1])/(f[j]-f[j-1])\)，那么无论再怎么增加\(dp[i][j]\)也不可能最优。所以将\(j\)下标看做二维点\((f[j],dp[i][j])\)后，所有可能的最优值形成一个下凸壳。当整块\(dp[i][j]+=f[j]\)后，凸壳上仍是这些点，但最小值点可能将向左移动。于是我们只要不断删除凸壳右边的点，就可以每一块均摊\(O(1)\)的修改和查询最小值。
对于单点修改，只需要重构凸壳，复杂度为块大小。
现在考虑分块后从\(dp[i]\)转移到\(dp[i+1]\)的总复杂度，设块大小\(b\)。由于单点修改仅一个点\(k\)，故复杂度\(b\)；取最小值复杂度\(b+n/b\)；区间加复杂度\(b+n/b\)；区间\(dp[i][j]+=f[j]\)复杂度\(b+n/b\)。当\(b\)取\(\sqrt n\) 时复杂度最优，为\(\sqrt n \)。考虑到重构凸壳较慢，应在求最值时如需要再重构凸壳。
总时间复杂度\(O(n \sqrt n)\)
AC代码
1 #include<cstdio>
2 #include<cmath>
3 #include<algorithm>
4 #include<cstring>
5 using namespace std;
6 #define LL long long
7 struct Block{
8 LL a[400], tag, delta;
9 int order[400];
10 int pos[400], back, n;
11 bool flag;
12 void init(int b[], int size){
13 n = size; flag = true;
14 memcpy(order, b, sizeof(int)*n);
15 memset(a, 0x3f, sizeof(LL)*n);
16 }
17 bool check(int j1, int j, int j2){
18 return (a[j2] - a[j]) * (order[j] - order[j1]) <= (a[j] - a[j1]) * (order[j2] - order[j]);
19 }
20 LL get(int i){ return a[i] + tag * order[i] + delta; }
21 void update(){
22 for (int i = 0; i < n; i++)
23 a[i] = get(i);
24 tag = delta = 0; back = 0;
25 flag = false;
26 for (int i = 0; i < n; i++){
27 while (back>1 && check(pos[back - 1], pos[back], i))back--;
28 pos[++back] = i;
29 }
30 while (back > 1 && get(pos[back - 1]) <= get(pos[back]))back--;
31 }
32 void set(int i, LL val){
33 a[i] += val - get(i);
34 flag = true;
35 }
36 void add(int l, int r, int d){
37 if (l == 0 && r == n - 1)delta += d;
38 else{
39 for (int i = l; i <= r; i++)
40 a[i] += d;
41 flag = true;
42 }
43 }
44 void add2(int l, int r){
45 if (l == 0 && r == n - 1){
46 tag++;
47 while (back > 1 && get(pos[back - 1]) <= get(pos[back]))back--;
48 }
49 else{
50 for (int i = l; i <= r; i++)
51 a[i] += order[i];
52 flag = true;
53 }
54 }
55 LL queryMin(int l, int r){
56 if (l == 0 && r == n - 1){
57 if (flag)update();
58 return get(pos[back]);
59 }
60 LL ret = 1LL << 60;
61 for (int i = l; i <= r; i++)
62 ret = min(ret, get(i));
63 return ret;
64 }
65 }b[1000];
66 int a[100002], order[100002];
67 int belong[100002], offset[100002], blockSize;
68 void add(int l, int r, int delta){
69 int start = l / blockSize, end = r / blockSize;
70 for (int i = start; i <= end; i++)
71 b[i].add(i == start ? offset[l] : 0, i == end ? offset[r] : b[i].n - 1, delta);
72 }
73 void add2(int l, int r){
74 int start = l / blockSize, end = r / blockSize;
75 for (int i = start; i <= end; i++)
76 b[i].add2(i == start ? offset[l] : 0, i == end ? offset[r] : b[i].n - 1);
77 }
78 LL queryMin(int l, int r){
79 int start = l / blockSize, end = r / blockSize;
80 LL ret = 1LL << 60;
81 for (int i = start; i <= end; i++)
82 ret = min(ret, b[i].queryMin(i == start ? offset[l] : 0, i == end ? offset[r] : b[i].n - 1));
83 return ret;
84 }
85 int main(){
86 int n;
87 scanf("%d", &n);
88 for (int i = 1; i <= n; i++){
89 scanf("%d", &a[i]);
90 order[i] = a[i];
91 }
92 order[0] = 0;
93 sort(order, order + n + 1);
94 int cnt = unique(order, order + n + 1) - order;
95 blockSize = sqrt(cnt);
96 int j = 0, k = 0;
97 for (int i = 0; i < cnt; i++){
98 belong[i] = k;
99 offset[i] = j++;
100 if (j == blockSize){
101 b[k].init(order + i - j + 1, j);
102 j = 0; k++;
103 }
104 }
105 if (j)b[k].init(order + cnt - j, j);
106 b[0].set(0, 0);
107 int mpos = 0;
108 for (int i = 1; i <= n; i++){
109 int pos = lower_bound(order, order + cnt, a[i]) - order;
110 if (pos >= mpos)mpos = pos;
111 else{
112 LL val = queryMin(0, pos);
113 b[belong[pos]].set(offset[pos], val);
114 add(0, pos - 1, order[mpos] - order[pos]);
115 add(pos + 1, mpos, -order[pos]);
116 add2(pos + 1, mpos);
117 }
118 }
119 printf("%lld", queryMin(0, cnt - 1));
120 }
原文地址：https://www.cnblogs.com/zbh2047/p/9631762.html