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

#include <iostream>
#include <vector>
using namespace std;

int n, m;
int s[100005], t[100005];
vector<int> edge[10005], redge[10005];
bool used[10005];
vector<int> ord;
int comp[10005];
int noin[10005], noout[10005];

void dfs1(int a) {
  used[a] = true;
  for (int i = 0; i < edge[a].size(); i++) {
    int b = edge[a][i];
    if (!used[b])
      dfs1(b);
  }
  ord.push_back(a);
}

void dfs2(int a, int c) {
  // printf("%d ", a);
  used[a] = true;
  comp[a] = c;
  for (int i = 0; i < redge[a].size(); i++) {
    int b = redge[a][i];
    if (!used[b])
      dfs2(b, c);
  }
}

int main() {
  cin >> n >> m;
  for (int i = 0; i < m; i++) {
    cin >> s[i] >> t[i];
    edge[s[i]].push_back(t[i]);
    redge[t[i]].push_back(s[i]);
  }
  fill(used, used + n, false);
  for (int i = 0; i < n; i++)
    if (!used[i])
      dfs1(i);
  int cnt = 0;
  fill(used, used + n, false);
  for (int i = n - 1; i >= 0; i--) {
    if (!used[ord[i]]) {
      dfs2(ord[i], cnt++);
      // printf("\\n");
    }
  }
  fill(noin, noin + n, 1);
  fill(noout, noout + n, 1);
  for (int i = 0; i < m; i++) {
    if (comp[s[i]] != comp[t[i]]) {
      noout[comp[s[i]]] = 0;
      noin[comp[t[i]]] = 0;
    }
  }
  int ans = 0;
  if (cnt > 1) {
    int noincnt = 0, nooutcnt = 0;
    for (int i = 0; i < cnt; i++)
      noincnt += noin[i];
    for (int i = 0; i < cnt; i++)
      nooutcnt += noout[i];
    ans = max(noincnt, nooutcnt);
  }
  cout << ans << endl;
}

Error: TLE

Fixed submission:

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

// Macro Tools /////////////////////////////////////////////////////////////////
#define GET_MACRO_09(A0, A1, A2, A3, A4, A5, A6, A7, A8, NAME, ...) NAME

#define EXPAND_01(MACRO, A0, ...) MACRO(A0, ##__VA_ARGS__)
#define EXPAND_02(MACRO, A0, A1, ...)                                          \\
  MACRO(A0, ##__VA_ARGS__) MACRO(A1, ##__VA_ARGS__)
#define EXPAND_03(MACRO, A0, A1, A2, ...)                                      \\
  MACRO(A0, ##__VA_ARGS__) MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__)
#define EXPAND_04(MACRO, A0, A1, A2, A3, ...)                                  \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)
#define EXPAND_05(MACRO, A0, A1, A2, A3, A4, ...)                              \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)   \\
      MACRO(A4, ##__VA_ARGS__)
#define EXPAND_06(MACRO, A0, A1, A2, A3, A4, A5, ...)                          \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)   \\
      MACRO(A4, ##__VA_ARGS__) MACRO(A5, ##__VA_ARGS__)
#define EXPAND_07(MACRO, A0, A1, A2, A3, A4, A5, A6, ...)                      \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)   \\
      MACRO(A4, ##__VA_ARGS__) MACRO(A5, ##__VA_ARGS__)                        \\
          MACRO(A6, ##__VA_ARGS__)
#define EXPAND_08(MACRO, A0, A1, A2, A3, A4, A5, A6, A7, ...)                  \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)   \\
      MACRO(A4, ##__VA_ARGS__) MACRO(A5, ##__VA_ARGS__)                        \\
          MACRO(A6, ##__VA_ARGS__) MACRO(A7, ##__VA_ARGS__)
#define EXPAND_09(MACRO, A0, A1, A2, A3, A4, A5, A6, A7, A8, ...)              \\
  MACRO(A0, ##__VA_ARGS__)                                                     \\
  MACRO(A1, ##__VA_ARGS__) MACRO(A2, ##__VA_ARGS__) MACRO(A3, ##__VA_ARGS__)   \\
      MACRO(A4, ##__VA_ARGS__) MACRO(A5, ##__VA_ARGS__)                        \\
          MACRO(A6, ##__VA_ARGS__) MACRO(A7, ##__VA_ARGS__)                    \\
              MACRO(A8, ##__VA_ARGS__)

#define GET_EXPAND(...)                                                        \\
  GET_MACRO_09(__VA_ARGS__, EXPAND_09, EXPAND_08, EXPAND_07, EXPAND_06,        \\
               EXPAND_05, EXPAND_04, EXPAND_03, EXPAND_02, EXPAND_01)
#define EXPAND_ARG_0(MACRO, ...) GET_EXPAND(__VA_ARGS__)(MACRO, __VA_ARGS__)
#define EXPAND_ARG_1(MACRO, A0, ...)                                           \\
  GET_EXPAND(__VA_ARGS__)(MACRO, __VA_ARGS__, A0)

#define EXPAND(MACRO, ...) EXPAND_ARG_0(MACRO, __VA_ARGS__)

#define Q(x) #x
#define QUOTE(x) Q(x)

// Input ///////////////////////////////////////////////////////////////////////
#define SCANF_INT(a) scanf("%d", &(a));
#define ID(...) int __VA_ARGS__;
#define IR(...)                                                                \\
  { EXPAND(SCANF_INT, __VA_ARGS__) }
#define I(...) ID(__VA_ARGS__) IR(__VA_ARGS__)

// #define DEFINE_INT_ARRAY(a, n) int a[n];
// #define INT_ITH_ARRAY(a, i) a[i]
// #define IAD(N, ...) EXPAND_ARG_1(DEFINE_INT_ARRAY, N, __VA_ARGS__)
// #define IAR(N, ...) REP(array_reader_i, N){

#define SCANF_LL(a) scanf("%lld", &(a));
#define LD(...) ll __VA_ARGS__;
#define LR(...)                                                                \\
  { EXPAND(SCANF_LL, __VA_ARGS__) }
#define L(...) LD(__VA_ARGS__) LR(__VA_ARGS__)

#define SCANF_LD(a) scanf("%Lf", &(a));
#define DD(...) lD __VA_ARGS__;
#define DR(...)                                                                \\
  { EXPAND(SCANF_LD, __VA_ARGS__) }
#define D(...) DD(__VA_ARGS__) DR(__VA_ARGS__)

#define DEFINE_STR(a, n) char a[n];
#define SCANF_STR(a) scanf("%s", a);
#define SD(N, ...) EXPAND_ARG_1(DEFINE_STR, N, __VA_ARGS__)
#define SR(...) EXPAND(SCANF_STR, __VA_ARGS__)
#define S(N, ...) SD(N, __VA_ARGS__) SR(__VA_ARGS__)

// Output //////////////////////////////////////////////////////////////////////
#define LN printf("\\n")
#define FL fflush(stdout)

#define IP(a, ...) printf("%d", a);

// Types ///////////////////////////////////////////////////////////////////////
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef set<int> si;
typedef set<ll> sll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef list<int> li;
typedef list<ll> lll;
typedef map<int, int> mii;
typedef map<int, ll> mil;
typedef map<ll, int> mli;
typedef map<ll, ll> mll;

// Loop & Iteration ////////////////////////////////////////////////////////////
#define FORT(t, i, a, b)                                                       \\
  for (t i = (a), loop_end_##i = (b); i < (loop_end_##i); i++)
#define FORL(i, a, b) FORT(ll, i, a, b)
#define FOR(i, a, b) FORT(int, i, a, b)
#define REPT(t, i, n) FORT(t, i, 0, n)
#define REPL(i, n) FORL(i, 0, n)
#define REP(i, n) FOR(i, 0, n)
#define EACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)

#define EXIST(s, e) ((s).find(e) != (s).end())
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort(ALL(a))
#define SORTA(a, n) sort(a, a + n)

#define PB push_back
#define MP make_pair
#define itr iterator

// Range ///////////////////////////////////////////////////////////////////////
#define IN(x, a, b) (a <= x && x < b)
#define INC(x, a, b) (a <= x && x <= b)
int dx[8] = {1, 0, 0, -1, 1, 1, -1, -1};
int dy[8] = {0, -1, 1, 0, -1, 1, -1, 1};

#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))

// Debug ///////////////////////////////////////////////////////////////////////
#define println(...)                                                           \\
  {                                                                            \\
    printf(__VA_ARGS__);                                                       \\
    printf("\\n");                                                              \\
  }
#ifdef LOCAL
#define debug(...) printf(__VA_ARGS__)
#define debugln(...) println(__VA_ARGS__)
#else
#define debug(...)                                                             \\
  {}
#define debugln(...)                                                           \\
  {}
#endif

// Numbers /////////////////////////////////////////////////////////////////////
ll gcd(ll a, ll b) {
  if (b == 0)
    return a;
  else
    return gcd(b, a % b);
}

#define PRIME_MAX 1000000
bool isprime[PRIME_MAX + 5];
void init_prime() {
  fill(isprime, isprime + PRIME_MAX + 5, true);
  isprime[0] = isprime[1] = false;
  REP(i, PRIME_MAX + 5) {
    if (isprime[i]) {
      for (int j = i * 2; j < PRIME_MAX; j += i) {
        isprime[j] = false;
      }
    }
  }
}

vll factors(ll n) {
  vll v;
  REPL(i, PRIME_MAX) {
    if (!isprime[i])
      continue;
    while (n % i == 0) {
      v.PB(i);
      n /= i;
    }
  }
  if (n > 1) {
    v.PB(n);
  }
  return v;
}

// BIT /////////////////////////////////////////////////////////////////////////
template <typename T = int> class bit {
public:
  T *bit_arr;
  int size;

  bit(int n) {
    size = n;
    bit_arr = new T[n];
    fill(bit_arr, bit_arr + n, 0);
  }

  ~bit() { delete bit_arr; }

  T sum(int a) {
    T ret = 0;
    while (a) {
      ret += bit_arr[a];
      a -= a & -a;
    }
    return ret;
  }

  T sum(int a, int b) { return sum(b) - sum(a); }

  T get(int a) { return sum(a, a + 1); }

  void add(int a, T x) {
    a++;
    while (a < size) {
      bit_arr[a] += x;
      a += a & -a;
    }
  }

  void set(int a, T x) { add(a, x - get(a)); }
};
typedef bit<ll> bll;

// RMQ /////////////////////////////////////////////////////////////////////////
template <typename T = int, class Compare = less<T>> class rmq {
public:
  int size;
  Compare comp;
  T *dat;
  T init;

  rmq(int n, T init_ = INT_MAX) {
    init = init_;
    size = 1;
    while (size < n)
      size *= 2;
    dat = new T[2 * size - 1];
    fill(dat, dat + (2 * size - 1), init);
  }

  ~rmq() { delete dat; }

  void set(int k, T a) {
    k += size - 1;
    dat[k] = a;
    while (k > 0) {
      k = (k - 1) / 2;
      dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2], comp);
    }
  }

  T get(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l)
      return init;
    if (a <= l && r <= b)
      return dat[k];
    else {
      T vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
      T vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
      return min(vl, vr, comp);
    }
  }

  T get(int a, int b) { return get(a, b, 0, 0, size); }
};

// Others //////////////////////////////////////////////////////////////////////
#define MOD 1000000007
#define YES() printf("YES\\n")
#define NO() printf("NO\\n")

////////////////////////////////////////////////////////////////////////////////

#define N 11234
// int pp[N];
// int d[N];
// int parn(int a){
//  if(pp[a]==a) return a;
//  else return pp[a]=parn(pp[a]);
// }
// void unte(int a, int b){
//  a=pp[a];
//  b=pp[b];
//  if(d[a]>d[b]){
//      pp[b]=a;
//      LAR(d[a], d[b]+1);
//  }else{
//      pp[a]=b;
//      LAR(d[b], d[a]+1);
//  }
// }

vi x[N], y[N];
vi w[N], z[N];
stack<int> que;
int a[N];
vi b;
vector<vi> v;
int g[N];
void dfa(int p) {
  a[p] = 0;
  REP(i, x[p].size()) {
    int j = x[p][i];
    if (a[j] == -1) {
      dfa(j);
    }
  }
  b.PB(p);
}
void dfb(int p) {
  v[v.size() - 1].PB(p);
  g[p] = v.size() - 1;
  a[p] = 0;
  REP(i, y[p].size()) {
    int j = y[p][i];
    if (a[j]) {
      dfb(j);
    }
  }
}
int s[N], t[N], vis[N];
void dfc(int p, int q) {
  vis[p] = 0;
  if (z[p].size() == 0 && w[p].size())
    s[q]++;
  if (w[p].size() == 0 && z[p].size())
    t[q]++;
  REP(i, w[p].size()) {
    int j = w[p][i];
    if (vis[j])
      dfc(j, q);
  }
  REP(i, z[p].size()) {
    int j = z[p][i];
    if (vis[j])
      dfc(j, q);
  }
}

int main() {
  I(n, m);
  REP(i, m) {
    I(p, q);
    x[p].PB(q);
    y[q].PB(p);
    // unte(p, q);
  }
  fill(a, a + N, -1);
  REP(i, n) {
    if (a[i] == -1) {
      dfa(i);
    }
  }
  reverse(ALL(b));
  // REP(i, b.size()) printf("%d ", b[i]); printf("\\n\\n");
  fill(a, a + N, 1);
  REP(i, n) {
    if (a[b[i]]) {
      v.PB(vi());
      dfb(b[i]);
    }
  }
  // REP(i, v.size()){
  //  REP(j, v[i].size()) printf("%d ", v[i][j]); printf("\\n");
  // }
  REP(i, n) {
    REP(j, x[i].size()) {
      int aa = g[i], bb = g[x[i][j]];
      if (aa != bb) {
        // printf("%d->%d\\n", aa, bb);
        w[aa].PB(bb);
        z[bb].PB(aa);
      }
    }
  }
  REP(i, v.size()) {
    sort(ALL(w[i]));
    unique(ALL(w[i]));
    sort(ALL(z[i]));
    unique(ALL(z[i]));
  }
  fill(s, s + N, 0);
  fill(t, t + N, 0);
  fill(vis, vis + N, 1);
  int ind = 0;
  REP(i, v.size()) {
    if (vis[i]) {
      dfc(i, ind++);
    }
  }
  // REP(i, ind) printf("%d %d\\n", s[i], t[i]);
  int ans = 0;
  if (m == 0)
    while (1)
      ans++;
  if (ind >= 2) {
    ans += ind;
    REP(i, ind) {
      if (s[i])
        s[i]--;
      if (t[i])
        t[i]--;
    }
  }
  int ss = 0, tt = 0;
  REP(i, ind) {
    ss += s[i];
    tt += t[i];
  }
  ans += max(ss, tt);
  printf("%d\\n", ans);
}