Problem p03275 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <bits/stdc++.h>
using namespace std;

template <class T> struct BIT {
  vector<T> lst;
  int treesize;
  // constructor
  BIT(int newn = 0) {
    treesize = newn;
    lst.resize(treesize + 1);
    for (int i = 0; i <= treesize; ++i)
      lst[i] = 0;
  }
  // a_place += num
  bool add(int place, T num) {
    while (place <= treesize) {
      lst[place] += num;
      place += place & -place;
    }
    return 1;
  }
  // add wide ver.(add num between l and r)
  bool addw(int left, int right, T num) {
    while (left <= right && left >= 1 && right <= treesize)
      add(left++, num);
    return 1;
  }
  // sum between l and r
  T calcsum(int place) {
    T answer = 0;
    while (place > 0) {
      answer += lst[place];
      place -= place & -place;
    }
    return answer;
  }
  // sum between l and r(calcsum wide ver.)
  T calcsumw(int left, int right) { return calcsum(right) - calcsum(left - 1); }
};

long long n, req;
vector<long long> a, ls;

long long solve();
bool isans(long long now);

int main() {
  cin >> n;
  for (int i = 0; i < n; ++i) {
    long long x;
    cin >> x;
    a.push_back(x);
    ls.push_back(x);
  }
  req = (n * (n + 1) + 2) / 4;
  sort(ls.begin(), ls.end());
  ls.erase(unique(ls.begin(), ls.end()), ls.end());
  for (int i = 0; i < ls.size(); ++i)
    isans(ls[i]);
  cout << solve() << endl;
  return 0;
}

long long solve() {
  long long l = 0, r = ls.size() - 1, now = ls[0];
  while (r - l > 0) {
    if (r - l == 1) {
      if (isans(ls[r]))
        now = ls[r];
      else
        now = ls[l];
      break;
    } else {
      now = ls[(r + l) / 2];
      if (isans(now))
        l = (r + l) / 2;
      else
        r = (r + l) / 2;
    }
  }
  return now;
}
// yes 1,no 0
bool isans(long long now) {
  BIT<long long> bits = BIT<long long>(1 + n), inv = BIT<long long>(3 * n);
  long long ans = 0;
  // calculate cumlative number(1 or -1 progression)
  for (int i = 0; i <= n; ++i) {
    if (i == 0 || a[i - 1] >= now)
      bits.add(i + 1, 1);
    else
      bits.add(i + 1, -1);
  }
  // avoid runtime error
  bits.add(1, n);
  // calculate inversion number
  for (int i = 1; i <= n + 1; ++i) {
    ans += inv.calcsum(bits.calcsum(i));
    inv.add(bits.calcsum(i), 1);
  }
  // cout << now << " " << ans << " " << req << endl;
  if (ans >= req)
    return 1;
  else
    return 0;
}

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

template <class T> struct BIT {
  vector<T> lst;
  int treesize;
  // constructor
  BIT(int newn = 0) {
    treesize = newn;
    lst.resize(treesize + 1);
    for (int i = 0; i <= treesize; ++i)
      lst[i] = 0;
  }
  // a_place += num
  bool add(int place, T num) {
    while (place <= treesize) {
      lst[place] += num;
      place += place & -place;
    }
    return 1;
  }
  // add wide ver.(add num between l and r)
  bool addw(int left, int right, T num) {
    while (left <= right && left >= 1 && right <= treesize)
      add(left++, num);
    return 1;
  }
  // sum between l and r
  T calcsum(int place) {
    T answer = 0;
    while (place > 0) {
      answer += lst[place];
      place -= place & -place;
    }
    return answer;
  }
  // sum between l and r(calcsum wide ver.)
  T calcsumw(int left, int right) { return calcsum(right) - calcsum(left - 1); }
};

long long n, req;
vector<long long> a, ls;

long long solve();
bool isans(long long now);

int main() {
  cin >> n;
  for (int i = 0; i < n; ++i) {
    long long x;
    cin >> x;
    a.push_back(x);
    ls.push_back(x);
  }
  req = (n * (n + 1) + 2) / 4;
  sort(ls.begin(), ls.end());
  ls.erase(unique(ls.begin(), ls.end()), ls.end());
  cout << solve() << endl;
  return 0;
}

long long solve() {
  long long l = 0, r = ls.size() - 1, now = ls[0];
  while (r - l > 0) {
    if (r - l == 1) {
      if (isans(ls[r]))
        now = ls[r];
      else
        now = ls[l];
      break;
    } else {
      now = ls[(r + l) / 2];
      if (isans(now))
        l = (r + l) / 2;
      else
        r = (r + l) / 2;
    }
  }
  return now;
}
// yes 1,no 0
bool isans(long long now) {
  BIT<long long> bits = BIT<long long>(1 + n), inv = BIT<long long>(3 * n);
  long long ans = 0;
  // calculate cumlative number(1 or -1 progression)
  for (int i = 0; i <= n; ++i) {
    if (i == 0 || a[i - 1] >= now)
      bits.add(i + 1, 1);
    else
      bits.add(i + 1, -1);
  }
  // avoid runtime error
  bits.add(1, n);
  // calculate inversion number
  for (int i = 1; i <= n + 1; ++i) {
    ans += inv.calcsum(bits.calcsum(i));
    inv.add(bits.calcsum(i), 1);
  }
  // cout << now << " " << ans << " " << req << endl;
  if (ans >= req)
    return 1;
  else
    return 0;
}