Problem p00459 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>

using namespace std;

#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define REP(i, x, y) for (int i = (x); i < (y); ++i)
#define MP(a, b) make_pair((a), (b))
#define F_ first
#define S_ second

typedef long long int lli;
typedef pair<int, int> Pi;

const int INF = 100000000;
const long long int INF_ = 100000000000000000;

struct Segment {
  int s, e /*,size()*/;
  Segment(int a, int b) : s(a), e(b) {}
  int size() { return e - s + 1; }
};

void Split(vector<Segment> *state, int i, int x, int y) {
  state[i % 2].clear();
  int idx = i % 2, prev_idx = (i + 1) % 2;
  {
    int s = 0;
    bool flag = true;
    REP(j, 0, state[prev_idx].size()) {
      s += state[prev_idx][j].size();
      if (y < s) {
        if (flag) {
          state[idx].push_back(Segment(state[prev_idx][j].s +
                                           state[prev_idx][j].size() - (s - y),
                                       state[prev_idx][j].e));
          flag = false;
        } else {
          state[idx].push_back(state[prev_idx][j]);
        }
      }
    }
  }
  {
    int s = 0;
    bool flag = true;
    REP(j, 0, state[prev_idx].size()) {
      s += state[prev_idx][j].size();
      if (y <= s) {
        if (flag) {
          state[idx].push_back(Segment(state[prev_idx][j].s +
                                           state[prev_idx][j].size() - (s - x),
                                       state[prev_idx][j].e - (s - y)));
        } else {
          state[idx].push_back(
              Segment(state[prev_idx][j].s, state[prev_idx][j].e - (s - y)));
        }
        break;
      } else if (x < s) {
        if (flag) {
          state[idx].push_back(Segment(state[prev_idx][j].s +
                                           state[prev_idx][j].size() - (s - x),
                                       state[prev_idx][j].e));
          flag = false;
        } else {
          state[idx].push_back(state[prev_idx][j]);
        }
      }
    }
  }
  {
    int s = 0;
    REP(j, 0, state[prev_idx].size()) {
      s += state[prev_idx][j].size();
      if (x <= s) {
        state[idx].push_back(Segment(
            state[prev_idx][j].s,
            state[prev_idx][j].s + state[prev_idx][j].size() - (s - x) - 1));
        break;
      } else {
        state[idx].push_back(state[prev_idx][j]);
      }
    }
  }
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  int N;
  while (cin >> N && N) {
    int M, P, Q, R;
    cin >> M >> P >> Q >> R;
    vector<int> X(M), Y(M);
    REP(i, 0, M) cin >> X[i] >> Y[i];
    vector<Segment> state[2];
    state[0].push_back(Segment(1, N));
    // cout << endl;
    REP(i, 1, M + 1) {
      Split(state, i, X[i - 1], Y[i - 1]);
      /*
      REP(j,0,state[i].size()){
              cout << state[i][j].s << ' ' << state[i][j].e << ' ' <<
      state[i][j].size() << endl;
      }
      cout << endl;
      */
    }
    int ans = 0;
    int s = 0;
    bool flag = true;
    int idx = M % 2;
    REP(i, 0, state[idx].size()) {
      s += state[idx][i].size();
      int tmp = 0;
      if (Q <= s) {
        if (R < state[idx][i].s)
          break;
        if (flag) {
          tmp = min(R, state[idx][i].s + state[idx][i].size() - (s - Q) - 1) -
                (state[idx][i].s + state[idx][i].size() - (s - P) - 1) + 1;
        } else {
          tmp = min(R, state[idx][i].s + state[idx][i].size() - (s - Q) - 1) -
                state[idx][i].s + 1;
        }
        ans += tmp;
        break;
      } else if (P <= s) {
        if (flag) {
          if (R >= state[idx][i].s)
            tmp = min(R, state[idx][i].e) -
                  (state[idx][i].s + state[idx][i].size() - (s - P) - 1) + 1;
          flag = false;
        } else {
          if (R >= state[idx][i].s)
            tmp += min(R, state[idx][i].e) - state[idx][i].s + 1;
        }
        ans += tmp;
      }
    }
    cout << ans << endl;
  }
  return 0;
}

Error: MLE

Fixed submission:

#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>

using namespace std;

#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define REP(i, x, y) for (int i = (x); i < (y); ++i)
#define MP(a, b) make_pair((a), (b))
#define F_ first
#define S_ second

typedef long long int lli;
typedef pair<int, int> Pi;

const int INF = 100000000;
const long long int INF_ = 100000000000000000;

struct Segment {
  int s, e /*,size()*/;
  Segment(int a, int b) : s(a), e(b) {}
  int size() { return e - s + 1; }
};

void Split(vector<Segment> *state, int i, int x, int y) {
  {
    int s = 0;
    bool flag = true;
    REP(j, 0, state[i - 1].size()) {
      s += state[i - 1][j].size();
      if (y < s) {
        if (flag) {
          state[i].push_back(
              Segment(state[i - 1][j].s + state[i - 1][j].size() - (s - y),
                      state[i - 1][j].e));
          flag = false;
        } else {
          state[i].push_back(state[i - 1][j]);
        }
      }
    }
  }
  {
    int s = 0;
    bool flag = true;
    REP(j, 0, state[i - 1].size()) {
      s += state[i - 1][j].size();
      if (y <= s) {
        if (flag) {
          state[i].push_back(
              Segment(state[i - 1][j].s + state[i - 1][j].size() - (s - x),
                      state[i - 1][j].e - (s - y)));
        } else {
          state[i].push_back(
              Segment(state[i - 1][j].s, state[i - 1][j].e - (s - y)));
        }
        break;
      } else if (x < s) {
        if (flag) {
          state[i].push_back(
              Segment(state[i - 1][j].s + state[i - 1][j].size() - (s - x),
                      state[i - 1][j].e));
          flag = false;
        } else {
          state[i].push_back(state[i - 1][j]);
        }
      }
    }
  }
  {
    int s = 0;
    REP(j, 0, state[i - 1].size()) {
      s += state[i - 1][j].size();
      if (x <= s) {
        state[i].push_back(
            Segment(state[i - 1][j].s,
                    state[i - 1][j].s + state[i - 1][j].size() - (s - x) - 1));
        break;
      } else {
        state[i].push_back(state[i - 1][j]);
      }
    }
  }
}

int main() {
  int N;
  while (cin >> N && N) {
    int M, P, Q, R;
    cin >> M >> P >> Q >> R;
    vector<int> X(M), Y(M);
    REP(i, 0, M) cin >> X[i] >> Y[i];
    vector<Segment> state[5001];
    state[0].push_back(Segment(1, N));
    // cout << endl;
    REP(i, 1, M + 1) {
      Split(state, i, X[i - 1], Y[i - 1]);
      /*
      REP(j,0,state[i].size()){
              cout << state[i][j].s << ' ' << state[i][j].e << ' ' <<
      state[i][j].size() << endl;
      }
      cout << endl;
      */
    }
    int ans = 0;
    int s = 0;
    bool flag = true;
    REP(i, 0, state[M].size()) {
      s += state[M][i].size();
      int tmp = 0;
      if (Q <= s) {
        if (R < state[M][i].s)
          break;
        if (flag) {
          tmp = min(R, state[M][i].s + state[M][i].size() - (s - Q) - 1) -
                (state[M][i].s + state[M][i].size() - (s - P) - 1) + 1;
        } else {
          tmp = min(R, state[M][i].s + state[M][i].size() - (s - Q) - 1) -
                state[M][i].s + 1;
        }
        ans += tmp;
        break;
      } else if (P <= s) {
        if (flag) {
          if (R >= state[M][i].s)
            tmp = min(R, state[M][i].e) -
                  (state[M][i].s + state[M][i].size() - (s - P) - 1) + 1;
          flag = false;
        } else {
          if (R >= state[M][i].s)
            tmp += min(R, state[M][i].e) - state[M][i].s + 1;
        }
        ans += tmp;
      }
    }
    cout << ans << endl;
  }
  return 0;
}