Алгоритмы на графах / flows / preflow

{ Ї®ЁбЄ ¬ ЄбЁ¬ «м­®Ј® Ї®в®Є  }
{ ¬Ґв®¤®¬ ўлв «ЄЁў ­Ёп ЇаҐў®б室п饣® Ї®в®Є  }

const
  maxn = 100;

var
  n, m: integer;                                { Є®«-ў® ўҐаиЁ­ Ё ¤гЈ }
  s, t: integer;                                { Ёбв®Є Ё бв®Є }
  i, w, nl, head, oldh, res: integer;
  f: array [1..maxn, 1..maxn] of integer;       { Ї®в®Є }
  c: array [1..maxn, 1..maxn] of integer;       { Їа®ЇгбЄ­лҐ бЇ®б®Ў­®бвЁ ¤гЈ }
  ss: array [1..maxn, 1..maxn] of integer;      {}
  e: array [1..maxn] of integer;                { Ё§Ўлв®Є }
  ne, cur, next, prev, l, h: array [1..maxn] of integer;


{min: ¬Ё­Ё¬г¬ Ё§ ¤ўге 楫ле зЁбҐ«}
function min(a, b: integer): integer;
begin
  if a > b then min := b else min := a;
end;

{ push: Їа®в «ЄЁў Ґв Ї®в®Є Ё§ ўҐаиЁ­Ґ u ў ўҐаи­Ёг v }
procedure push(u, v: integer);
var
  d: integer;
begin
  d := min(e[u], c[u, v] - f[u, v]);    { d - ¬Ё­Ё¬г¬ Ё§ Ё§ЎлвЄ  Ё          }
                                        { ®бв в®з­®© Їа®ЇгбЄ­®© бЇ®б®Ў­®бвЁ }
  e[u] := e[u] - d;                     { 㬥­ми Ґ¬ Ё§Ўлв®Є ўҐаиЁ­л u }
  e[v] := e[v] + d;                     { 㢥«ЁзЁў Ґ¬ Ё§Ўлв®Є ўҐаиЁ­л v }

  f[u,v] :=  f[u,v] + d;                { 㢥«ЁзЁў Ґ¬ Ї®в®Є Ї® ¤гЈҐ u->v }
  f[v,u] := -f[u,v];                    { бзЁв Ґ¬ Ї®в®Є Ї® ®Ўа в­®© ¤гЈҐ }
end;

{ lift: ўлб®в  ўҐаиЁ­л u Ўг¤Ґв а ў­  ўлб®вҐ б ¬®© ­Ё§Є®© ўҐаиЁ­л + 1}
procedure lift(u: integer);
var
  v: integer;
begin
  h[u] := 2 * n;

  for v := 1 to n do                { ЇҐаҐЎЁа Ґ¬ ўбҐ ўҐаиЁ­л ®бв в®з­®© бҐвЁ }
    if (c[u,v] - f[u,v] > 0) and    { ॡ஠u->v ­Ґ§ Ї®«­Ґ­® }
       (h[v] < h[u]) then           { Ё ўлб®в  v ¬Ґ­миҐ ўлб®вл u }
      h[u]:=h[v];

  inc(h[u]);
end;

{ discharge: а §Јаг§Є  ўҐаиЁ­л }
procedure discharge(u:integer);
var
  v: integer;
begin
  while e[u] > 0 do
  begin
    v := ss[u, cur[u]];
    if v = 0 then
    begin
      lift(u);
      cur[u]:=1;
    end
    else if (c[u, v] - f[u, v] > 0) and (h[u] = h[v]+1) then
      push(u, v)
    else
      inc(cur[u]);
  end;
end;

{ init: Ё­ЁжЁ «Ё§ жЁп Ё з⥭ЁҐ ¤ ­­ле }
procedure init;
var
  x, y, z, i: integer;
begin
  assign(input, 'flow.in');
  reset(input);

  read(n, m);
  s := 1;
  t := n;

  for i := 1 to m do
  begin
    read(x, y, z);

    inc(ne[x]);
    ss[x, ne[x]] := y;
    inc(ne[y]);
    ss[y, ne[y]] := x;
    c[x, y] := z;
  end;
end;

procedure init_preflow;
var
  i: integer;
begin
  h[s] := n;

  for i := 1 to n do
  begin
    if c[s, i] > 0 then
    begin
      f[s, i] :=  c[s, i];
      f[i, s] := -c[s, i];
      e[i] := e[i] + c[s, i];
    end;

    if (i <> s) and (i <> t) then
    begin
      cur[i] := 1;
      inc(nl);
      l[nl] := i;
    end;
  end;
end;

{ solve: аҐиҐ­ЁҐ § ¤ зЁ }
procedure solve;
var
  u: integer;
begin
  init_preflow;

  for i := 1 to nl do
  begin
    prev[i] := i - 1;
    next[i] := i + 1;
  end;

  if nl <> 0 then
  begin
    next[nl] := 0;
    head := 1;
    i := head;
  end
  else
    i := 0;

  while i > 0 do
  begin
    u := L[i];
    oldh:=h[u];
    Discharge(u);
    if (h[u]<>oldh)and(i<>head) then begin
      if next[i]<>0 then prev[next[i]]:=prev[i];
      next[prev[i]]:=next[i];
      next[i]:=head;
      prev[i]:=0; prev[head]:=i;
      head:=i;
    end;
    i:=next[i];
  end;


end;

{ done: Ї®¤бзҐв १г«мв в  Ё ҐЈ® ўлў®¤ }
procedure done;
var
  i: integer;
begin
  res := 0;
  for i := 1 to n do
    res := res + f[s, i];

  writeln(res);
  close(input);
end;

begin
  init;
  solve;
  done;
end.