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

{ Ї®ЁбЄ ¬ ЄбЁ¬ «м­®Ј® Ї®в®Є  ў бҐвЁ by boris }
{ ¬Ґв®¤ ”®а¤ -” «ЄҐаб®­  }
{  «Ј®аЁв¬ ќ¤¬®­¤б -Љ аЇ  }
{ ¤«п Ї®ЁбЄ   гЈ¬Ґ­в «м­®Ј® ЇгвЁ ЁбЇ®«м§гҐвбп  «Ј®аЁв¬ „Ґ©Єбвал }
{ Ј¤Ґ ўҐб ¬Ё бзЁв Ґвбп ­ҐЁбЇ®«м§®ў ­­ п Їа®ЇгбЄ­ п бЇ®б®Ў­®бвм }

{- Љ®­бв ­вл Ё ЇҐаҐ¬Ґ­­лҐ -}

const
  maxn = 100;                            { ¬ Єб. Є®«-ў® ўҐаиЁ­ }
  oo   = maxint;                         { ЎҐбЄ®­Ґз­®бвм }

var
  { Ї®в®Є }
  f: array [1..maxn, 1..maxn] of integer;  { f[i, j] = -f[j, i] }
  { Їа®ЇгбЄ­лҐ бЇ®б®Ў­®бвЁ }
  c: array [1..maxn, 1..maxn] of integer;
  { Є®«ЁзҐбвў® ўҐиаЁ­}
  n: integer;

{- Ђ«Ј®аЁв¬ „Ґ©Єбвал -}

{ ЏҐаҐ¬Ґ­­лҐ }

var
  { ­®¬Ґа ЇаҐ¤л¤г饩 ўҐаиЁ­л}
  p: array [1..maxn] of integer;
  { Ї®бҐйҐ­­®бвм }
  v: array [1..maxn] of boolean;
  { Єа вз ©иЁҐ а ббв®п­Ёп ®в Ёбв®Є  }
  d: array [1..maxn] of longint;

function edge(i, j: integer): integer;
begin
  if c[i, j] - f[i, j] > 0 then
    edge := c[i, j] - f[i, j]
  else
    edge := oo;
end;

function dijkstra(s, t: integer): boolean;
var
  i, j, k: integer;
  min: longint;
begin
  fillchar(v, sizeof(v), false);

  for i := 1 to n do
  begin
    p[i] := s;
    d[i] := edge(s, i);
  end;

  p[s] := 0;
  d[s] := 0;
  v[s] := true;

  for i := 1 to n-1 do
  begin
    min := oo;

    for j := 1 to n do
      if not v[j] and (d[j] < min) then
      begin
        min := d[j];
        k   := j;
      end;

    v[k] := true;

    for j := 1 to n do
      if not v[j] and (d[j] > d[k] + edge(k, j)) then
      begin
        d[j] := d[k] + edge(k, j);
        p[j] := k;
      end;
  end;

  dijkstra := d[t] <> oo;
end;


{- Ћб­®ў­лҐ Їа®жҐ¤гал -}

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

{ maxflow: §­ зҐ­Ёп ¬ ЄбЁ¬ «м­®Ј® Ї®в®Є  }
{ Ї®в®Є еа ­Ёвбп ў ¬ ваЁжҐ f, s-Ёбв®Є, t-бв®Є }
function maxflow(s, t: integer): integer;
var
  k: integer;
  d, flow: longint;
begin
  fillchar(f, sizeof(f), 0);            { ®Ў­г«пҐ¬ f }
  flow := 0;                            { Ї®в®Є Їгбв®© }

  while dijkstra(s, t) do                    { Џ®Є  бгйҐбвўгҐв Їгвм ®в Ёбв®Є  ў }
  begin                                 { ў бв®Є ў ®бв в®з­®© бҐвЁ, ЁйҐ¬   }
    d := oo;                            { ॡ஠ў н⮬ ЇгвЁ б ¬Ё­Ё¬ «м­®©  }
    k := t;                             { ­ҐЁбЇ®«м§®ў ­­®© Їа®ЇгбЄ­®©      }
    while k <> s do                     { бЇ®б®Ў­®бвмо                     }
    begin
      d := min(d, c[p[k], k]-f[p[k], k]);
      k := p[k];                        { ЎҐаҐ¬ ўҐаиЁ­г-ЇаҐ¤®Є }
    end;

    k := t;                             { Ё¤Ґ¬ Ї® ­ ©¤Ґ­®¬г ЇгвЁ ®в бв®Є   }
    while k <> s do                     { Є Ёбв®Єг                         }
    begin
      f[p[k], k] := f[p[k], k] + d;     { 㢥«ЁзЁў Ґ¬ Ї® Їап¬л¬ ॡࠬ }
      f[k, p[k]] := f[k, p[k]] - d;     { 㬥­ми Ґ¬ Ї® ®Ўа в­л¬ ॡࠬ }
      k := p[k];                        { ЎҐаҐ¬ ўҐаиЁ­г-ЇаҐ¤®Є }
    end;

    flow := flow + d;                   { 㢥«ЁзЁў Ґ¬ Ї®в®Є }
  end;

  maxflow := flow;                      { ў®§ўа й Ґ¬ ¬ ЄбЁ¬ «м­л© Ї®в®Є }
end;

{ init: Ё­ЁжЁ «Ё§ жЁп Ё ўў®¤ ¤ ­­ле }
procedure init;
var
  m, i, x, y, z: integer;
begin
  fillchar(c, sizeof(c), 0);

  assign(input, 'flow.in');
  reset(input);

  read(n, m);

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

  close(input);
end;

{solve: аҐиҐ­ЁҐ }
procedure solve;
begin
  writeln(maxflow(1, n));
end;

{- ѓ« ў­ п Їа®Ја ¬¬  -}

begin
  init;
  solve;
end.