p524.cpp
======================
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;
vector<int> a;

void read() {
    cin >> n;
    a.resize(n);
    cin >> a;
}

long double f(long double l, long double d) {
    long double ans = 0;
    for(int i = 0; i < n; i++) {
        ans += abs(a[i] - (l + d * i));
    }
    return ans;
}

pair<long double, long double> f(long double d) {
    long double l = -1e12, r = 1e12, m1, m2, ans_l = 0;
    for(int steps = 0; steps < 100; steps++) {
        m1 = l + (r - l) / 3;
        m2 = r - (r - l) / 3;
        if(f(m1, d) < f(m2, d)) {
            r = m2;
            ans_l = m1;
        } else {
            l = m1;
            ans_l = m2;
        }
    }

    return {f(ans_l, d), ans_l};
}

void solve() {
    sort(a.begin(), a.end());

    long double l = 0, r = 1e7, m1, m2, ans_d = 1;
    for(int steps = 0; steps < 100; steps++) {
        m1 = l + (r - l) / 3;
        m2 = r - (r - l) / 3;
        if(f(m1).first < f(m2).first) {
            r = m2;
            ans_d = m1;
        } else {
            l = m1;
            ans_d = m2;
        }
    }

    pair<long double, long double> ans = f(ans_d);
    cout << setprecision(9) << fixed << ans.first << '\n';
    for(int i = 0; i < n; i++) {
        cout << setprecision(9) << fixed << ans.second + ans_d * i << ' ';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}

=================
statement.txt
======================
524. Buoys
Time limit per test: 0.5 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard



The swimming area of Berhattan's city beach is marked out with n buoys. The buoys form a straight line. When the buoys were being put into the water, nobody cared to observe the same distance between each pair of adjacent buoys.

Now the beach keeper wants the distance between any two adjacent buoys to be the same. He plans to shift some or all of the buoys without changing their respective order. To facilitate the task, he wants the total length of all shifts to be as small as possible.

Given coordinates of the buoys, you should find the minimum possible length of all shifts, as well as new coordinates of the buoys.

Input
The first line of input contains a single integer n (2 ≤ n ≤ 400), n — the number of buoys. The second line contains buoys' integer coordinates x1, x2,..., xn (-10000 ≤ xi ≤ 10000). No two given buoys will share the same place. The coordinates are given in strictly increasing order.

Output
To the first line print a real number t — the minimum possible total length of required shifts. Output this value with at least 4 digits after the decimal point.

To the second line print n numbers — new coordinates of the buoys. The new coordinates should be printed in strictly increasing order with at least 7 digits after the decimal point. If there are several optimal ways to shift the buoys, you may output any of them.

Example(s)
sample input
sample output
4 -2 2 6 9 
1.0000
-2.0000000000 1.6666666667 5.3333333333 9.0000000000 



Note
All buoys are located on the Ox axis. You may move buoys only along the Ox axis.

=================
