Ural 2072 Kirill the Gardener 3

给出一个数组，$val_{i..n}$
求一个该数组排列，$ord_{1..n}$，满足$\forall i\in[1,n),val_{ord_i}\leq val_{ord_{i+1}}$，并且使得$\sum\limits_{i=1}^{n-1}abs(ord_i - ord_{i+1})$ 最小

首先很容易的就能想因为要满足排列之后数非降，我们能调整的只有$val$相同的位置的顺序
然后一个能想到的想法是对输入的数进行离散化，然后建立$m（m是离散化之后的数的数量）$层的图，每一层的点满足$val$相同，从高到低$val$递增，只有上下层或者同一层的点之间连有一条边，边权为两个点之间的距离，然后跑一遍最短哈密顿路径就好了

理想很美好，但是最短哈密顿路径是一个知名的$NP$问题，所以还需要优化一下

---

你可能会注意到，每一层的点之中只有两个端点是最重要的，只要保证你访问过这两个端点，那么这一层的点其实你都能经过一遍（想一想，为什么）
然后我们就可以把每一层不是端点的点都丢掉了
也就是说，现在每一层我们都只有两个点了

然后的dp过程就很trivial了

设$dp_{i,0}和dp_{i,1}$分别为在第$i$层并且在左/右端点访问完这一层所有其他点的花费，然后就可以很开心的$dp$了

---

                                我是代码的分割线

---

#include<vector>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

const int maxn = 112345;
#define LL long long
vector<int> node[maxn];

int arr[maxn];
int val[maxn];

LL dp[maxn][2];
LL loca[maxn][2];

void init(int n){
    for(int i=0;i<=n;i++){
        node[i].clear();
    }
}

int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d",&arr[i]);
            val[i] = arr[i];
        }
        val[n] = 0;
        int bound = n+1;
        sort(val,val+bound);

        bound = unique(val,val+bound) - val;
        for(int i=0;i<n;i++){
            arr[i] = lower_bound(val,val+bound,arr[i])-val;
        }
        init(n);
        for(int i=0;i<n;i++){
            node[arr[i]].push_back(i);
        }
        for(int i=1;i<bound;i++){
            sort(node[i].begin(),node[i].end());
            loca[i][0] = node[i][0];
            loca[i][1] = node[i][node[i].size()-1];
        }
        memset(dp,0x3f,sizeof(dp));
        dp[0][0] = dp[0][1] =0;
        loca[0][0] = loca[0][1] = 0;
        for(int i=1;i<bound;i++){
            LL lsize = abs(loca[i][0] - loca[i][1]);
            LL & b0 = loca[i-1][0];
            LL & b1 = loca[i-1][1];
            LL & a0 = loca[i][0];
            LL & a1 = loca[i][1];
            dp[i][0] = min(dp[i-1][0]+min(lsize + abs(b0 - a1),lsize * 2 + abs(b0-a0)),
                           dp[i-1][1]+min(lsize + abs(b1 - a1),lsize * 2 + abs(b1-a0)));
            dp[i][1] = min(dp[i-1][0]+min(lsize + abs(b0 - a0),lsize * 2 + abs(b0-a1)),
                           dp[i-1][1]+min(lsize + abs(b1 - a0),lsize * 2 + abs(b1-a1)));
        }
        printf("%lld\n",min(dp[bound-1][0],dp[bound-1][1])+n);
    }
    return 0;
}