XVIII Open Cup named after E.V. Pankratiev. Grand Prix of Khamovniki Problem J Stairways解题报告（分块+维护凸壳）

首先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

5
100 4 3 2 1

Sample Output

详细题解

此题很容易用DP来做。考虑前\(i\)个人，则两个楼梯必有一个的通行时间变为前\(i\)个人最慢的那个，我们设\(dp[i][j]\)表示前\(i\)个人另一个楼梯当前通行时间是\(j\)（\(j\)从小到大离散化）时的最优答案，则考虑\(dp[i+1]\)和\(dp[i]\)的关系：

（1）若\(a[i+1] \ge 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\le 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代码

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 #define LL long long
 struct Block{
     LL a[], tag, delta;
     int order[];
     int pos[], back, n;
     bool flag;
     void init(int b[], int size){
         n = size; flag = true;
         memcpy(order, b, sizeof(int)*n);
         memset(a, 0x3f, sizeof(LL)*n);
     }
     bool check(int j1, int j, int j2){
         return (a[j2] - a[j]) * (order[j] - order[j1]) <= (a[j] - a[j1]) * (order[j2] - order[j]);
     }
     LL get(int i){ return a[i] + tag * order[i] + delta; }
     void update(){
         for (int i = ; i < n; i++)
             a[i] = get(i);
         tag = delta = ; back = ;
         flag = false;
         for (int i = ; i < n; i++){
             while (back> && check(pos[back - ], pos[back], i))back--;
             pos[++back] = i;
         }
         while (back >  && get(pos[back - ]) <= get(pos[back]))back--;
     }
     void set(int i, LL val){
         a[i] += val - get(i);
         flag = true;
     }
     void add(int l, int r, int d){
         if (l ==  && r == n - )delta += d;
         else{
             for (int i = l; i <= r; i++)
                 a[i] += d;
             flag = true;
         }
     }
     void add2(int l, int r){
         if (l ==  && r == n - ){
             tag++;
             while (back >  && get(pos[back - ]) <= get(pos[back]))back--;
         }
         else{
             for (int i = l; i <= r; i++)
                 a[i] += order[i];
             flag = true;
         }
     }
     LL queryMin(int l, int r){
         if (l ==  && r == n - ){
             if (flag)update();
             return get(pos[back]);
         }
         LL ret = 1LL << ;
         for (int i = l; i <= r; i++)
             ret = min(ret, get(i));
         return ret;
     }
 }b[];
 int a[], order[];
 int belong[], offset[], blockSize;
 void add(int l, int r, int delta){
     int start = l / blockSize, end = r / blockSize;
     for (int i = start; i <= end; i++)
         b[i].add(i == start ? offset[l] : , i == end ? offset[r] : b[i].n - , delta);
 }
 void add2(int l, int r){
     int start = l / blockSize, end = r / blockSize;
     for (int i = start; i <= end; i++)
         b[i].add2(i == start ? offset[l] : , i == end ? offset[r] : b[i].n - );
 }
 LL queryMin(int l, int r){
     int start = l / blockSize, end = r / blockSize;
     LL ret = 1LL << ;
     for (int i = start; i <= end; i++)
         ret = min(ret, b[i].queryMin(i == start ? offset[l] : , i == end ? offset[r] : b[i].n - ));
     return ret;
 }
 int main(){
     int n;
     scanf("%d", &n);
     for (int i = ; i <= n; i++){
         scanf("%d", &a[i]);
         order[i] = a[i];
     }
     order[] = ;
     sort(order, order + n + );
     int cnt = unique(order, order + n + ) - order;
     blockSize = sqrt(cnt);
     int j = , k = ;
     for (int i = ; i < cnt; i++){
         belong[i] = k;
         offset[i] = j++;
         if (j == blockSize){
             b[k].init(order + i - j + , j);
             j = ; k++;
         }
     }
     if (j)b[k].init(order + cnt - j, j);
     b[].set(, );
     int mpos = ;
     for (int i = ; i <= n; i++){
         int pos = lower_bound(order, order + cnt, a[i]) - order;
         if (pos >= mpos)mpos = pos;
         else{
             LL val = queryMin(, pos);
             b[belong[pos]].set(offset[pos], val);
             add(, pos - , order[mpos] - order[pos]);
             add(pos + , mpos, -order[pos]);
             add2(pos + , mpos);
         }
     }
     printf("%lld", queryMin(, cnt - ));
 }