[P3453] [POI2007] DRZ - Trees

毫无技术含量的题目。

首先，特判 $1$ 和 $n$ 的答案，还有相邻的贡献。

然后记 $l_i = min(a_{i - 1}, a_{i + 1})$，记 $r_i = max(a_{i - 1}, a_{i + 1})$，记 $s_i = |a_i - a_{i - 1}| + |a_i - a_{i + 1}|$，考虑 $i$ 和 $j$ 所作贡献（$i, j \in [2,n], |i - j| > 1$）：

（1）$a_i < l_j$，$a_j < l_i$

$\delta = l_i + r_i - 2a_i - s_i + l_j + r_j - 2a_j - s_j$

（2）$l_j \le a_i < r_j$，$a_j < l_i$

$\delta = l_i + r_i - s_i + r_j - l_j - 2a_j - s_j$

（3）$a_i \ge r_j$，$a_j < l_i$

$\delta = l_i + r_i + 2a_i - s_i - l_j - r_j - 2a_j - s_j$

（4）$a_i < l_j$，$l_i \le a_j < r_i$

$\delta = r_i - l_i - 2a_i - s_i + l_j + r_j - s_j$

（5）$l_j \le a_i < r_j$，$l_i \le a_j < r_i$

$\delta = r_i - l_i - s_i + r_j - l_j - s_j$

（6）$a_i \ge r_j$，$l_i \le a_j < r_i$

$\delta = r_i - l_i + 2a_i - s_i - l_j - r_j - s_j$

（7）$a_i < l_j$，$a_j \ge r_i$

$\delta = -l_i - r_i - 2a_i - s_i + l_j + r_j + 2a_j - s_j$

（8）$l_j \le a_i < r_j$，$a_j \ge r_i$

$\delta = -l_i - r_i - s_i + r_j - l_j + 2a_j - s_j$

（9）$a_i \ge r_j$，$a_j \ge r_i$

$\delta = -l_i - r_i + 2a_i - s_i - l_j - r_j + 2a_j - s_j$

把 $j$ 看作修改，把 $i$ 看作询问。

$j$ 对应的修改看成 $(l, a_j)$ 到 $(r, a_j)$ 的线段（限制为 $l \le a_i \le r$）。

$i$ 对应的询问看成 $(a_i, l')$ 到 $(a_i, r')$ 的线段（限制为 $l' \le a_j \le r'$）。

两个线段有交即产生贡献，直接对 $x$ 轴扫描线即可。

为了满足 $|i - j| > 1$，所以首先离散化的时候不应该去重，然后询问的时候特判 $a_{i - 1}$ 和 $a_{i + 1}$ 两个纵坐标不计算贡献。$a_i$ 计算贡献无所谓，因为其贡献为 $0$。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 5e4 + 10, INF = numeric_limits<int>::max();
int n, a[MAXN], s[MAXN], id[MAXN], rev[MAXN], sz;
pair<int, int> bd[MAXN];
ll ans[MAXN], sans;
vector<pair<int, int>> op[MAXN];
inline void chsmin(ll &x, const ll &y) { y < x && (x = y); }
ll calc(int x, int y) {
    ll ret = 0;
    if (x != 1) ret += abs(a[y] - a[x - 1]) - abs(a[x] - a[x - 1]);
    if (y != n) ret += abs(a[x] - a[y + 1]) - abs(a[y] - a[y + 1]);
    if (x + 1 != y) {
        ret += abs(a[x] - a[y - 1]) - abs(a[y] - a[y - 1]) +
               abs(a[y] - a[x + 1]) - abs(a[x] - a[x + 1]);
    }
    return ret;
}
namespace sgt {
int mn[MAXN * 4];
inline int ls(int p) { return p << 1; }
inline int rs(int p) { return p << 1 | 1; }
inline void push_up(int p) { mn[p] = min(mn[ls(p)], mn[rs(p)]); }
void build(int p, int l, int r) {
    mn[p] = INF;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(ls(p), l, mid);
    build(rs(p), mid + 1, r);
}
void update(int p, int l, int r, int x, int v) {
    if (l == r) {
        mn[p] = v;
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) {
        update(ls(p), l, mid, x, v);
    } else {
        update(rs(p), mid + 1, r, x, v);
    }
    push_up(p);
}
int query(int p, int l, int r, int ql, int qr) {
    if (ql > qr) return INF;
    if (ql <= l && r <= qr) return mn[p];
    int mid = (l + r) >> 1;
    if (qr <= mid) {
        return query(ls(p), l, mid, ql, qr);
    } else if (ql > mid) {
        return query(rs(p), mid + 1, r, ql, qr);
    } else {
        return min(query(ls(p), l, mid, ql, qr),
                   query(rs(p), mid + 1, r, ql, qr));
    }
}
}  // namespace sgt
int query(int p, int l, int r) {
    int x = bd[p].first, y = bd[p].second;
    if (r == y) --r;
    if (r == x) --r;
    if (l == x) ++l;
    if (l == y) ++l;
    if (l > r) return INF;
    if ((x < l && r < y) || r < x || l > y) return sgt::query(1, 1, n, l, r);
    if (l < x && r > y) {
        return min({sgt::query(1, 1, n, l, x - 1),
                    sgt::query(1, 1, n, x + 1, y - 1),
                    sgt::query(1, 1, n, y + 1, r)});
    }
    if (l < x) {
        return min(sgt::query(1, 1, n, l, x - 1),
                   sgt::query(1, 1, n, x + 1, r));
    }
    return min(sgt::query(1, 1, n, l, y - 1), sgt::query(1, 1, n, y + 1, r));
}
void solve1() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[1].emplace_back(id[i], a[i - 1] + a[i + 1] - a[i] * 2 - s[i]);
        op[bd[i].first].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, 1, bd[p].first - 1) + a[p - 1] +
                               a[p + 1] - a[p] * 2 - s[p]);
        }
    }
}
void solve2() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[bd[i].first].emplace_back(
            id[i], abs(a[i - 1] - a[i + 1]) - a[i] * 2 - s[i]);
        op[bd[i].second].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, 1, bd[p].first - 1) + a[p - 1] +
                               a[p + 1] - s[p]);
        }
    }
}
void solve3() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[bd[i].second].emplace_back(id[i],
                                      -a[i - 1] - a[i + 1] - a[i] * 2 - s[i]);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, 1, bd[p].first - 1) + a[p - 1] +
                               a[p + 1] + a[p] * 2 - s[p]);
        }
    }
}
void solve4() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[1].emplace_back(id[i], a[i - 1] + a[i + 1] - s[i]);
        op[bd[i].first].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, bd[p].first, bd[p].second - 1) +
                               abs(a[p - 1] - a[p + 1]) - a[p] * 2 - s[p]);
        }
    }
}
void solve5() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[bd[i].first].emplace_back(id[i], abs(a[i - 1] - a[i + 1]) - s[i]);
        op[bd[i].second].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, bd[p].first, bd[p].second - 1) +
                               abs(a[p - 1] - a[p + 1]) - s[p]);
        }
    }
}
void solve6() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i)
        op[bd[i].second].emplace_back(id[i], -a[i - 1] - a[i + 1] - s[i]);
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, bd[p].first, bd[p].second - 1) +
                               abs(a[p - 1] - a[p + 1]) + a[p] * 2 - s[p]);
        }
    }
}
void solve7() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[1].emplace_back(id[i], a[i - 1] + a[i + 1] + a[i] * 2 - s[i]);
        op[bd[i].first].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, bd[p].second, n) - a[p - 1] - a[p + 1] -
                               a[p] * 2 - s[p]);
        }
    }
}
void solve8() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[bd[i].first].emplace_back(
            id[i], abs(a[i - 1] - a[i + 1]) + a[i] * 2 - s[i]);
        op[bd[i].second].emplace_back(id[i], INF);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p],
                   (ll)query(p, bd[p].second, n) - a[p - 1] - a[p + 1] - s[p]);
        }
    }
}
void solve9() {
    for (int i = 1; i <= n; ++i) op[i].clear();
    for (int i = 2; i < n; ++i) {
        op[bd[i].second].emplace_back(id[i],
                                      -a[i - 1] - a[i + 1] + a[i] * 2 - s[i]);
    }
    sgt::build(1, 1, n);
    for (int i = 1; i <= n; ++i) {
        for (auto &j : op[i]) sgt::update(1, 1, n, j.first, j.second);
        int p = rev[i];
        if (p != 1 && p != n) {
            chsmin(ans[p], (ll)query(p, bd[p].second, n) - a[p - 1] - a[p + 1] +
                               a[p] * 2 - s[p]);
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    iota(rev + 1, rev + n + 1, 1);
    sort(rev + 1, rev + n + 1, [](int x, int y) { return a[x] < a[y]; });
    for (int i = 1; i <= n; ++i) id[rev[i]] = i;
    for (int i = 1; i < n; ++i) sans += abs(a[i] - a[i + 1]);
    for (int i = 2; i <= n; ++i) chsmin(ans[1], calc(1, i));
    for (int i = 1; i < n; ++i) chsmin(ans[n], calc(i, n));
    for (int i = 2; i <= n; ++i) {
        chsmin(ans[i],
               min({calc(1, i), calc(i - 1, i), calc(i, i + 1), calc(i, n)}));
    }
    for (int i = 2; i < n; ++i) {
        s[i] = abs(a[i + 1] - a[i]) + abs(a[i] - a[i - 1]);
        bd[i] = minmax(id[i - 1], id[i + 1]);
    }
    solve1();
    solve2();
    solve3();
    solve4();
    solve5();
    solve6();
    solve7();
    solve8();
    solve9();
    for (int i = 1; i <= n; ++i) cout << ans[i] + sans << "\n";
    return 0;
}