Problem p03411 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using namespace std;
using P = pair<long, long>;

typedef long long int ll;

#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))

#define fillInt(xs, x)                                                         \
  for (int i = 0; i < (x); i++)                                                \
    scanf("%d", &xs[i]);
#define fillLong(xs, x)                                                        \
  for (int i = 0; i < (x); i++)                                                \
    scanf("%ld", &xs[i]);
#define fillString(xs, x)                                                      \
  for (int i = 0; i < (x); i++)                                                \
    cin >> xs[i];
#define sortv(xs) sort(xs.begin(), xs.end())
#define sortvinv(xs) sort(xs.begin(), xs.end(), std::greater<long>())
#define lbv(xs, x) lower_bound(xs.begin(), xs.end(), x) - xs.begin()
#define ubv(xs, x) upper_bound(xs.begin(), xs.end(), x) - xs.begin()
#define bs(xs, x) binary_search(xs.begin(), xs.end(), x)
#define index_of(as, x)                                                        \
  distance(as.begin(), lower_bound(as.begin(), as.end(), x))

#define rep(i, n) for (auto i = 0; i < (n); i++)

const int mod = 1000000007;

typedef int FLOW;
const int MAX_V = 200;

struct Edge {
  int rev, from, to;
  FLOW cap, icap;
  Edge(int r, int f, int t, FLOW c) : rev(r), from(f), to(t), cap(c), icap(c) {}
};

struct Graph {
  int V;
  vector<Edge> list[MAX_V];

  Graph(int n = 0) : V(n) {
    for (int i = 0; i < MAX_V; ++i)
      list[i].clear();
  }
  void init(int n = 0) {
    V = n;
    for (int i = 0; i < MAX_V; ++i)
      list[i].clear();
  }
  void resize(int n = 0) { V = n; }
  void reset() {
    for (int i = 0; i < V; ++i)
      for (int j = 0; j < list[i].size(); ++j)
        list[i][j].cap = list[i][j].icap;
  }
  inline vector<Edge> &operator[](int i) { return list[i]; }

  Edge &redge(Edge e) {
    if (e.from != e.to)
      return list[e.to][e.rev];
    else
      return list[e.to][e.rev + 1];
  }

  void addedge(int from, int to, FLOW cap) {
    list[from].push_back(Edge((int)list[to].size(), from, to, cap));
    list[to].push_back(Edge((int)list[from].size() - 1, to, from, 0));
  }
};

static int level[MAX_V];
static int iter[MAX_V];

void dibfs(Graph &G, int s) {
  for (int i = 0; i < MAX_V; ++i)
    level[i] = -1;
  level[s] = 0;
  queue<int> que;
  que.push(s);
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    for (int i = 0; i < G[v].size(); ++i) {
      Edge &e = G[v][i];
      if (level[e.to] < 0 && e.cap > 0) {
        level[e.to] = level[v] + 1;
        que.push(e.to);
      }
    }
  }
}

FLOW didfs(Graph &G, int v, int t, FLOW f) {
  if (v == t)
    return f;
  for (int &i = iter[v]; i < G[v].size(); ++i) {
    Edge &e = G[v][i], &re = G.redge(e);
    if (level[v] < level[e.to] && e.cap > 0) {
      FLOW d = didfs(G, e.to, t, min(f, e.cap));
      if (d > 0) {
        e.cap -= d;
        re.cap += d;
        return d;
      }
    }
  }
  return 0;
}

FLOW Dinic(Graph &G, int s, int t) {
  FLOW res = 0;
  while (true) {
    dibfs(G, s);
    if (level[t] < 0)
      return res;
    memset(iter, 0, sizeof(iter));
    FLOW flow;
    while ((flow = didfs(G, s, t, INF)) > 0) {
      res += flow;
    }
  }
}

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

  int n;
  cin >> n;

  vector<pair<int, int>> v1(n);
  vector<pair<int, int>> v2(n);

  rep(i, n) {
    int a, b;
    cin >> a >> b;
    v1[i] = {a, b};
  }

  rep(i, n) {
    int a, b;
    cin >> a >> b;
    v2[i] = {a, b};
  }

  int size = 2 * n;
  Graph G(size + 2);
  int S_node = size;
  int T_node = size + 1;

  rep(i, n) { G.addedge(S_node, i, 1); }

  rep(i, n) { G.addedge(i + n, T_node, 1); }

  rep(i, n) rep(j, n) {
    if (v1[i].first < v2[j].first && v1[i].second < v2[j].second) {
      G.addedge(i, j + n, 1);
    }
  }

  FLOW res = Dinic(G, S_node, T_node);

  cout << res << endl;
}


Fixed submission:
#include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using namespace std;
using P = pair<long, long>;

typedef long long int ll;

#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))

#define fillInt(xs, x)                                                         \
  for (int i = 0; i < (x); i++)                                                \
    scanf("%d", &xs[i]);
#define fillLong(xs, x)                                                        \
  for (int i = 0; i < (x); i++)                                                \
    scanf("%ld", &xs[i]);
#define fillString(xs, x)                                                      \
  for (int i = 0; i < (x); i++)                                                \
    cin >> xs[i];
#define sortv(xs) sort(xs.begin(), xs.end())
#define sortvinv(xs) sort(xs.begin(), xs.end(), std::greater<long>())
#define lbv(xs, x) lower_bound(xs.begin(), xs.end(), x) - xs.begin()
#define ubv(xs, x) upper_bound(xs.begin(), xs.end(), x) - xs.begin()
#define bs(xs, x) binary_search(xs.begin(), xs.end(), x)
#define index_of(as, x)                                                        \
  distance(as.begin(), lower_bound(as.begin(), as.end(), x))

#define rep(i, n) for (auto i = 0; i < (n); i++)

const int mod = 1000000007;

typedef int FLOW;
const int MAX_V = 205;

struct Edge {
  int rev, from, to;
  FLOW cap, icap;
  Edge(int r, int f, int t, FLOW c) : rev(r), from(f), to(t), cap(c), icap(c) {}
};

struct Graph {
  int V;
  vector<Edge> list[MAX_V];

  Graph(int n = 0) : V(n) {
    for (int i = 0; i < MAX_V; ++i)
      list[i].clear();
  }
  void init(int n = 0) {
    V = n;
    for (int i = 0; i < MAX_V; ++i)
      list[i].clear();
  }
  void resize(int n = 0) { V = n; }
  void reset() {
    for (int i = 0; i < V; ++i)
      for (int j = 0; j < list[i].size(); ++j)
        list[i][j].cap = list[i][j].icap;
  }
  inline vector<Edge> &operator[](int i) { return list[i]; }

  Edge &redge(Edge e) {
    if (e.from != e.to)
      return list[e.to][e.rev];
    else
      return list[e.to][e.rev + 1];
  }

  void addedge(int from, int to, FLOW cap) {
    list[from].push_back(Edge((int)list[to].size(), from, to, cap));
    list[to].push_back(Edge((int)list[from].size() - 1, to, from, 0));
  }
};

static int level[MAX_V];
static int iter[MAX_V];

void dibfs(Graph &G, int s) {
  for (int i = 0; i < MAX_V; ++i)
    level[i] = -1;
  level[s] = 0;
  queue<int> que;
  que.push(s);
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    for (int i = 0; i < G[v].size(); ++i) {
      Edge &e = G[v][i];
      if (level[e.to] < 0 && e.cap > 0) {
        level[e.to] = level[v] + 1;
        que.push(e.to);
      }
    }
  }
}

FLOW didfs(Graph &G, int v, int t, FLOW f) {
  if (v == t)
    return f;
  for (int &i = iter[v]; i < G[v].size(); ++i) {
    Edge &e = G[v][i], &re = G.redge(e);
    if (level[v] < level[e.to] && e.cap > 0) {
      FLOW d = didfs(G, e.to, t, min(f, e.cap));
      if (d > 0) {
        e.cap -= d;
        re.cap += d;
        return d;
      }
    }
  }
  return 0;
}

FLOW Dinic(Graph &G, int s, int t) {
  FLOW res = 0;
  while (true) {
    dibfs(G, s);
    if (level[t] < 0)
      return res;
    memset(iter, 0, sizeof(iter));
    FLOW flow;
    while ((flow = didfs(G, s, t, INF)) > 0) {
      res += flow;
    }
  }
}

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

  int n;
  cin >> n;

  vector<pair<int, int>> v1(n);
  vector<pair<int, int>> v2(n);

  rep(i, n) {
    int a, b;
    cin >> a >> b;
    v1[i] = {a, b};
  }

  rep(i, n) {
    int a, b;
    cin >> a >> b;
    v2[i] = {a, b};
  }

  int size = 2 * n;
  Graph G(size + 2);
  int S_node = size;
  int T_node = size + 1;

  rep(i, n) { G.addedge(S_node, i, 1); }

  rep(i, n) { G.addedge(i + n, T_node, 1); }

  rep(i, n) rep(j, n) {
    if (v1[i].first < v2[j].first && v1[i].second < v2[j].second) {
      G.addedge(i, j + n, 1);
    }
  }

  FLOW res = Dinic(G, S_node, T_node);

  cout << res << endl;
}