#include <bits/stdc++.h>
using namespace std;


#define INF 0x3f3f3f3f3f3f3f3f
#define int long long
#define endl "\n"


#define debug(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); cout << "\n";}
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
    cerr << *it << " = " << a << "   ";
    err(++it, args...);
}
template <typename T>inline void rd(T &t) {
    int s = 0, w = 1;
    char ch = getchar();

    while (ch < '0' || ch > '9') {
        if (ch == '-')
            w = -1;

        ch = getchar();
    }

    while (ch >= '0' && ch <= '9')
        s = s * 10 + ch - '0', ch = getchar();

    t = s * w;
}
template <typename T, typename... Args> inline void rd(T &t, Args &... args) {
    rd(t);
    rd(args...);
}




typedef double db;
typedef long long ll;
typedef unsigned long long ull;

int qmi(int a, int k, int p) {
    int res = 1;

    while (k) {
        if (k & 1)
            res = (ll)res * a % p;

        a = (ll)a * a % p;
        k >>= 1;
    }

    return res;
}
int qpow(int a, int b) {
    int res = 1;

    while (b) {
        if (b & 1)
            res *= a;

        b >>= 1;
        a *= a;
    }

    return res;
}
int mo(int x, int p) {
    return x = ((x % p) + p) % p;
}
int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}


const int maxn = 1e6 + 7;
const int mod = 1e9 + 7;
const double eps = 1e-6;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};

int T = 1, N, M, K, Q;


template <typename T>
struct Fenwick {
    const int n;
    std::vector<T> a;
    Fenwick(int n) : n(n), a(n) {}
    void add(int x, T v) {
        for (int i = x; i < n; i += i & -i) {
            a[i] += v;
        }
    }
    T sum(int x) {
        T ans = 0;

        for (int i = x; i > 0; i -= i & -i) {
            ans += a[i];
        }

        return ans;
    }
    T rangeSum(int l, int r) {
        return sum(r) - sum(l - 1);
    }
};



void solve() {
    cin >> N;
    vector<int> H(N + 1), id(N + 1);

    for (int i = 1; i <= N; i ++) {
        cin >> H[i];
        id[i] = i;
    }

    sort(id.begin() + 1, id.end(), [&](int i, int j) {
        return H[i] > H[j];
    });

    Fenwick<int> t(N + 1);
    int now = 0, ans = 0;

    for (int i = 1; i <= N; i ++) {
        if (i < N && H[id[i]] == H[id[i + 1]]) {
            vector<int> all;

            for (int j = i; j <= N && H[id[j]] == H[id[i]]; j++) {
                all.push_back(id[j]);
            }

            for (auto x : all) {
                ans += min(t.sum(x), now - t.sum(x));
            }

            for (auto x : all) {
                t.add(x, 1);
                // debug(x);
            }

            now += all.size();
            i += all.size() - 1;
            // debug(ans);
            continue;
        }

        int r = t.sum(id[i]);
        int l = now - r;
        ans += min(l, r);
        t.add(id[i], 1);
        now ++;
        // debug(ans);
    }

    cout << ans << endl;


}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    // cin >> T;
    for (int i = 1; i <= T; i ++)
        solve();

    return (0 - 0); //<3
}