Weird Sum

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

#define int long long

const int ms = 100003;

vector<int> xBucket[ms];
vector<int> xPsum[ms];

vector<int> yBucket[ms];
vector<int> yPsum[ms];

int32_t main() {

    int n, m;
    cin >> n >> m;

    vector< vector<int> > M(n, vector<int>(m));

    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < m; ++j) {
            cin >> M[i][j];
            xBucket[ M[i][j] ].push_back(i);
            xPsum[ M[i][j] ].push_back(0);

            yBucket[ M[i][j] ].push_back(j);
            yPsum[ M[i][j] ].push_back(0);
        }
    }

    for(int i = 0; i < ms; ++i) {
        sort(xBucket[i].begin(), xBucket[i].end());
        sort(yBucket[i].begin(), yBucket[i].end());
    }

    for(int i = 0; i < ms; ++i) {
        for(int j = 0; j < xBucket[i].size(); ++j) {
            if(!j) xPsum[i][j] = xBucket[i][j];
            else xPsum[i][j] = xBucket[i][j] + xPsum[i][j - 1];
        }
    }

    for(int i = 0; i < ms; ++i) {
        for(int j = 0; j < yBucket[i].size(); ++j) {
            if(!j) yPsum[i][j] = yBucket[i][j];
            else yPsum[i][j] = yBucket[i][j] + yPsum[i][j - 1];
        }
    }

    int answer = 0;

    auto updAnsX = [&](int i, int j) {
        int x = M[i][j];
        auto it = upper_bound(xBucket[x].begin(), xBucket[x].end(), i);
        if(it == xBucket[x].begin()) {
            answer += xPsum[x].back() - xPsum[x].size() * i;
        } else if(it == xBucket[x].end()) {
            answer += xPsum[x].size() * i - xPsum[x].back();
        } else {
            int p = it - xBucket[x].begin() - 1;
            answer += (p + 1) * i - xPsum[x][p];
            answer += (xPsum[x].back() - xPsum[x][p]) - ((int)xBucket[x].size() - p - 1) * i;
        }
    };

    auto updAnsY = [&](int i, int j) {
        int y = M[i][j];
        auto it = upper_bound(yBucket[y].begin(), yBucket[y].end(), j);
        if(it == yBucket[y].begin()) {
            answer += yPsum[y].back() - yPsum[y].size() * j;
        } else if(it == yBucket[y].end()) {
            answer += yPsum[y].size() * j - yPsum[y].back();
        } else {
            int p = it - yBucket[y].begin() - 1;
            answer += (p + 1) * j - yPsum[y][p];
            answer += (yPsum[y].back() - yPsum[y][p]) - ((int)yBucket[y].size() - p - 1) * j;
        }
    };

    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < m; ++j) {
            updAnsX(i, j);
            updAnsY(i, j);
        }
    }

    answer /= 2;

    cout << answer << endl;

    return 0;
}