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



#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#include <cassert>

namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
  dsu() : _n(0) {}
  dsu(int n) : _n(n), parent_or_size(n, -1) {}

  int merge(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    int x = leader(a), y = leader(b);
    if (x == y)
      return x;
    if (-parent_or_size[x] < -parent_or_size[y])
      std::swap(x, y);
    parent_or_size[x] += parent_or_size[y];
    parent_or_size[y] = x;
    return x;
  }

  bool same(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    return leader(a) == leader(b);
  }

  int leader(int a) {
    assert(0 <= a && a < _n);
    if (parent_or_size[a] < 0)
      return a;
    return parent_or_size[a] = leader(parent_or_size[a]);
  }

  int size(int a) {
    assert(0 <= a && a < _n);
    return -parent_or_size[leader(a)];
  }

  std::vector<std::vector<int>> groups() {
    std::vector<int> leader_buf(_n), group_size(_n);
    for (int i = 0; i < _n; i++) {
      leader_buf[i] = leader(i);
      group_size[leader_buf[i]]++;
    }
    std::vector<std::vector<int>> result(_n);
    for (int i = 0; i < _n; i++) {
      result[i].reserve(group_size[i]);
    }
    for (int i = 0; i < _n; i++) {
      result[leader_buf[i]].push_back(i);
    }
    result.erase(
        std::remove_if(result.begin(), result.end(),
                       [&](const std::vector<int> &v) { return v.empty(); }),
        result.end());
    return result;
  }

private:
  int _n;
  // root node: -1 * component size
  // otherwise: parent
  std::vector<int> parent_or_size;
};

} // namespace atcoder

using namespace atcoder;

bool jud(pair<ll, ll> a, pair<ll, ll> b) {
  bool flag = false;
  if (a.first < b.first && a.second < b.second) {
    flag = true;
  }
  if (a.first > b.first && a.second > b.second) {
    flag = true;
  }
  return flag;
}

int main() {

  int N;

  cin >> N;

  vector<pair<pair<int, int>, int>> vp;

  int x, y;

  for (int i = 0; i < N; i++) {
    cin >> x >> y;
    vp.emplace_back(make_pair(x, y), i);
  }

  sort(vp.begin(), vp.end(),
       [](pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
         return a.first.first < b.first.first;
       });
  /*
      for(int i=0;i<N;i++){
          cout<<vp[i].first.first<<":"<<vp[i].first.second<<":"<<vp[i].second<<endl;
      }
  */
  set<pair<int, int>> st; //(y,id)  yが最小かつ

  dsu d(N);
  for (int i = 0; i < N; i++) {

    int org = vp[i].first.second;
    int id = vp[i].second;
    int l = org;

    // cout<<"org:"<<org<<" id:"<<id<<" l:"<<l<<endl;

    set<pair<int, int>>::iterator itr = st.begin();

    while (!st.empty()) {
      // cout<<"judge: y:"<<itr->first<<" id:"<<itr->second<<endl;

      if (itr->first < org) {
        l = min(l, itr->first);
        d.merge(itr->second, id);
        // cout<<"erase:y:"<<itr->first<<":id"<<itr->second<<endl;
        itr = st.erase(itr);
        // cout<<"l:"<<l<<endl;
      } else {
        break;
      }
    }
    // cout<<"add:y:"<<l<<" :id "<<id<<endl;
    st.emplace(l, id);
  }

  for (int i = 0; i < N; i++) {
    cout << d.size(i) << endl;
  }
}


Error: TLE

Fixed submission:



#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#include <cassert>

namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
  dsu() : _n(0) {}
  dsu(int n) : _n(n), parent_or_size(n, -1) {}

  int merge(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    int x = leader(a), y = leader(b);
    if (x == y)
      return x;
    if (-parent_or_size[x] < -parent_or_size[y])
      std::swap(x, y);
    parent_or_size[x] += parent_or_size[y];
    parent_or_size[y] = x;
    return x;
  }

  bool same(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    return leader(a) == leader(b);
  }

  int leader(int a) {
    assert(0 <= a && a < _n);
    if (parent_or_size[a] < 0)
      return a;
    return parent_or_size[a] = leader(parent_or_size[a]);
  }

  int size(int a) {
    assert(0 <= a && a < _n);
    return -parent_or_size[leader(a)];
  }

  std::vector<std::vector<int>> groups() {
    std::vector<int> leader_buf(_n), group_size(_n);
    for (int i = 0; i < _n; i++) {
      leader_buf[i] = leader(i);
      group_size[leader_buf[i]]++;
    }
    std::vector<std::vector<int>> result(_n);
    for (int i = 0; i < _n; i++) {
      result[i].reserve(group_size[i]);
    }
    for (int i = 0; i < _n; i++) {
      result[leader_buf[i]].push_back(i);
    }
    result.erase(
        std::remove_if(result.begin(), result.end(),
                       [&](const std::vector<int> &v) { return v.empty(); }),
        result.end());
    return result;
  }

private:
  int _n;
  // root node: -1 * component size
  // otherwise: parent
  std::vector<int> parent_or_size;
};

} // namespace atcoder

using namespace atcoder;
vector<pair<ll, ll>> vp;

bool jud(pair<ll, ll> a, pair<ll, ll> b) {
  bool flag = false;
  if (a.first < b.first && a.second < b.second) {
    flag = true;
  }
  if (a.first > b.first && a.second > b.second) {
    flag = true;
  }
  return flag;
}

int main() {
  ll N;
  cin >> N;
  vp.resize(N);

  for (ll i = 0; i < N; i++) {
    cin >> vp[i].first >> vp[i].second;
  }

  dsu d(N);

  for (ll i = 0; i < N - 1; i++) {
    for (ll j = i + 1; j < N; j++) {
      if (jud(vp[i], vp[j])) {

        d.merge(i, j);
      }
    }
  }

  for (int i = 0; i < N; i++) {
    cout << d.size(i) << endl;
  }
}