Problem p00650 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using namespace std;

#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c)                                                            \
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)

template <class T> void debug(T begin, T end) {
  for (T i = begin; i != end; ++i)
    cerr << *i << " ";
  cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
  return (x >= 0 && y >= 0 && x < W && y < H);
}

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
struct Edge {
  int src, dst, cap, rev;
  Edge(int u, int v, int c, int r) : src(u), dst(v), cap(c), rev(r) {}
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
void add_edge(Graph &G, int a, int b, int c) {
  G[a].push_back(Edge(a, b, c, G[b].size()));
  G[b].push_back(Edge(b, a, c, G[a].size() - 1));
}
int dfs(Graph &G, int u, int t, int f, vector<bool> &used) {
  if (u == t)
    return f;
  used[u] = true;
  FORIT(e, G[u]) if (e->cap > 0 && !used[e->dst]) {
    int g = dfs(G, e->dst, t, min(f, e->cap), used);
    if (g > 0) {
      e->cap -= g;
      G[e->dst][e->rev].cap += g;
      return g;
    }
  }
  return 0;
}
int max_flow(Graph G, int s, int t) {
  int N = G.size();
  int flow = 0;
  while (true) {
    vector<bool> used(N, false);
    int f = dfs(G, s, t, INF, used);
    if (f == 0)
      return flow;
    flow += f;
  }
}

int main() {
  int N, M;
  while (cin >> N >> M && N) {
    Graph G(N);
    int minus = 0;
    REP(i, M) {
      int a, b, c;
      cin >> a >> b >> c;
      if (c <= 0) {
        minus += c;
        continue;
      }
      add_edge(G, a, b, c);
    }
    int ans = INF;
    REP(s, N) REP(t, N) if (s != t) { ans = min(ans, max_flow(G, s, t)); }
    cout << ans + minus << endl;
  }
  return 0;
}

Fixed submission:
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

using namespace std;

#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c)                                                            \
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)

template <class T> void debug(T begin, T end) {
  for (T i = begin; i != end; ++i)
    cerr << *i << " ";
  cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
  return (x >= 0 && y >= 0 && x < W && y < H);
}

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
struct Edge {
  int src, dst, cap, rev;
  Edge(int u, int v, int c, int r) : src(u), dst(v), cap(c), rev(r) {}
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
void add_edge(Graph &G, int a, int b, int c) {
  G[a].push_back(Edge(a, b, c, G[b].size()));
  G[b].push_back(Edge(b, a, c, G[a].size() - 1));
}
int dfs(Graph &G, int u, int t, int f, vector<bool> &used) {
  if (u == t)
    return f;
  used[u] = true;
  FORIT(e, G[u]) if (e->cap > 0 && !used[e->dst]) {
    int g = dfs(G, e->dst, t, min(f, e->cap), used);
    if (g > 0) {
      e->cap -= g;
      G[e->dst][e->rev].cap += g;
      return g;
    }
  }
  return 0;
}
int max_flow(Graph G, int s, int t) {
  int N = G.size();
  int flow = 0;
  while (true) {
    vector<bool> used(N, false);
    int f = dfs(G, s, t, INF, used);
    if (f == 0)
      return flow;
    flow += f;
  }
}

int main() {
  int N, M;
  while (cin >> N >> M && N) {
    Graph G(N);
    int minus = 0;
    REP(i, M) {
      int a, b, c;
      cin >> a >> b >> c;
      if (c <= 0) {
        minus += c;
        continue;
      }
      add_edge(G, a, b, c);
    }
    int ans = INF;
    FOR(t, 1, N) { ans = min(ans, max_flow(G, 0, t)); }
    cout << ans + minus << endl;
  }
  return 0;
}