Problem p00486 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <algorithm>
#include <iostream>
#include <vector>

#pragma warning(disable : 4996)

using namespace std;

int H, W, N, A, B;

long long LX, LY, RX, RY; // rotate

vector<int> X;
vector<int> Y;
vector<int> EX; // sorted X
vector<int> EY; // sorted Y
vector<int> UX; // unique X
vector<int> UY; // unique Y

vector<long long> SX; // accumulation sum X
vector<long long> SY; // accumulation sum Y
vector<long long> DX; // distance sum from UX
vector<long long> DY; // distance sum from UY

long long sumx(int l, int r) { return SX[r] - SX[l]; }

long long sumy(int l, int r) { return SY[r] - SY[l]; }

int main() {
  // ------ Input ------ //

  scanf("%d", &W);
  scanf("%d", &H);
  scanf("%d", &N);

  X = vector<int>(N);
  Y = vector<int>(N);

  for (int i = 0; i < N; i++) {
    scanf("%d", &X[i]);
    scanf("%d", &Y[i]);
  }

  // ------ Sort & Unique ------ //

  EX = X;
  EY = Y;

  sort(EX.begin(), EX.end());
  UX.push_back(EX[0]);
  sort(EY.begin(), EY.end());
  UY.push_back(EY[0]);

  for (int i = 1; i < N; i++) {
    if (EX[i] != EX[i - 1]) {
      UX.push_back(EX[i]);
    }

    if (EY[i] != EY[i - 1]) {
      UY.push_back(EY[i]);
    }
  }

  A = UX.size();
  B = UY.size();

  // ------ Accumulation ------ //

  SX.push_back(0);
  SY.push_back(0);

  for (int i = 0; i < N; i++)
    SX.push_back(SX[i] + EX[i]);
  for (int i = 0; i < N; i++)
    SY.push_back(SY[i] + EY[i]);

  // ------ Rotate ------ //

  LX = 999999999999999999LL;
  LY = 999999999999999999LL;
  RX = -999999999999999999LL;
  RY = -999999999999999999LL;

  for (int i = 0; i < N; i++) {
    long long tx = X[i] + Y[i];
    long long ty = X[i] - Y[i];

    LX = min(LX, tx);
    LY = min(LY, ty);
    RX = max(RX, tx);
    RY = max(RY, ty);
  }

  // ------ Distance Calculation ------ //

  for (int i = 0; i < A; i++) {
    int ptrl = lower_bound(EX.begin(), EX.end(), UX[i]) - EX.begin();
    int ptrr = upper_bound(EX.begin(), EX.end(), UX[i]) - EX.begin();

    long long suml = 1LL * UX[i] * ptrl - 1LL * sumx(0, ptrl);
    long long sumr = 1LL * sumx(ptrr, N) - 1LL * UX[i] * (N - ptrr);

    DX.push_back(sumr + suml);
  }

  for (int i = 0; i < B; i++) {
    int ptrl = lower_bound(EY.begin(), EY.end(), UY[i]) - EY.begin();
    int ptrr = upper_bound(EY.begin(), EY.end(), UY[i]) - EY.begin();

    long long suml = 1LL * UY[i] * ptrl - sumy(0, ptrl);
    long long sumr = 1LL * sumy(ptrr, N) - 1LL * UY[i] * (N - ptrr);

    DY.push_back(sumr + suml);
  }

  // ------ Calculate ------ //

  long long ret = 999999999999999999LL;

  int x = -1, y = -1, pl = 0, pr = B, l, r;

  for (int i = 0; i < A; i++) {
    long long res = 999999999999999999LL;

    for (int j = pl; j < pr; j++) {
      long long rx = UX[i] + UY[j];
      long long ry = UX[i] - UY[j];

      long long maxs = max(max(rx - LX, RX - rx), max(ry - LY, RY - ry));

      long long sum = 2LL * (DX[i] + DY[j]) - maxs;

      if (sum < res) {
        res = sum;

        l = j;
        r = j + 1;

        if (sum < ret) {
          x = UX[i];
          y = UY[j];
        }
      } else if (sum == res) {
        r++;
      }
    }

    pl = max(l - 1, 0);
    pr = min(r + 1, B);

    ret = min(ret, res);
  }

  // ------ Output ------ //

  printf("%lld\\n", ret);

  printf("%d %d\\n", x, y);

  return 0;
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <iostream>
#include <vector>

#pragma warning(disable : 4996)

using namespace std;

int H, W, N, A, B;

long long LX, LY, RX, RY; // rotate

vector<int> X;
vector<int> Y;
vector<int> EX; // sorted X
vector<int> EY; // sorted Y
vector<int> UX; // unique X
vector<int> UY; // unique Y
vector<int> CX; // unique counts X
vector<int> CY; // unique counts Y

vector<long long> DX; // distance sum from UX
vector<long long> DY; // distance sum from UY

int main() {
  // ------ Input ------ //

  scanf("%d", &W);
  scanf("%d", &H);
  scanf("%d", &N);

  X = vector<int>(N);
  Y = vector<int>(N);

  for (int i = 0; i < N; i++) {
    scanf("%d", &X[i]);
    scanf("%d", &Y[i]);
  }

  // ------ Sort & Unique ------ //

  EX = X;
  EY = Y;

  sort(EX.begin(), EX.end());
  UX.push_back(EX[0]);
  sort(EY.begin(), EY.end());
  UY.push_back(EY[0]);

  int leftx = 0, lefty = 0;

  for (int i = 1; i < N; i++) {
    if (EX[i] != EX[i - 1]) {
      UX.push_back(EX[i]);
      CX.push_back(i - leftx);
      leftx = i;
    }

    if (EY[i] != EY[i - 1]) {
      UY.push_back(EY[i]);
      CY.push_back(i - lefty);
      lefty = i;
    }
  }

  CX.push_back(N - leftx);
  CY.push_back(N - lefty);

  A = UX.size();
  B = UY.size();

  // ------ Rotate ------ //

  LX = 999999999999999999LL;
  LY = 999999999999999999LL;
  RX = -999999999999999999LL;
  RY = -999999999999999999LL;

  for (int i = 0; i < N; i++) {
    long long tx = X[i] + Y[i];
    long long ty = X[i] - Y[i];

    LX = min(LX, tx);
    LY = min(LY, ty);
    RX = max(RX, tx);
    RY = max(RY, ty);
  }

  // ------ Distance Calculation ------ //

  for (int i = 0; i < A; i++) {
    long long sum = 0;

    for (int j = 0; j < A; j++) {
      sum += 1LL * abs(UX[i] - UX[j]) * CX[j];
    }

    DX.push_back(sum);
  }

  for (int i = 0; i < B; i++) {
    long long sum = 0;

    for (int j = 0; j < B; j++) {
      sum += 1LL * abs(UY[i] - UY[j]) * CY[j];
    }

    DY.push_back(sum);
  }

  // ------ Calculate ------ //

  long long ret = 999999999999999999LL;

  int x = -1, y = -1, pl = 0, pr = B, l, r;

  for (int i = 0; i < A; i++) {
    long long res = 999999999999999999LL;

    for (int j = pl; j < pr; j++) {
      long long rx = UX[i] + UY[j];
      long long ry = UX[i] - UY[j];

      long long maxs = max(max(rx - LX, RX - rx), max(ry - LY, RY - ry));

      long long sum = 2LL * (DX[i] + DY[j]) - maxs;

      if (sum < res) {
        res = sum;

        l = j;
        r = j + 1;

        if (sum < ret) {
          x = UX[i];
          y = UY[j];
        }
      } else if (sum == res) {
        r++;
      }
    }

    pl = max(l - 1, 0);
    pr = min(r + 1, B);

    ret = min(ret, res);
  }

  // ------ Output ------ //

  printf("%lld\\n", ret);

  printf("%d %d\\n", x, y);

  return 0;
}