bzoj 3171 费用流

每个格拆成两个点，出点连能到的点的入点，如果是箭头指向

方向费用就是0，要不就是1，源点连所有出点，所有入点连

汇点，然后费用流

/**************************************************************

    Problem: 3171

    User: BLADEVIL

    Language: Pascal

    Result: Accepted

    Time:32 ms

    Memory:1180 kb

****************************************************************/

 

//By BLADEVIL

var

    n, m                        :longint;

    map                         :array[0..30,0..30] of longint;

    pre, other, len, cost       :array[0..50010] of longint;

    last                        :array[0..10000] of longint;

    l                           :longint;

    num                         :array[0..30,0..30] of longint;

    go                          :array[0..2,0..4] of longint;

    source, sink                :longint;

    ans                         :longint;

    que, dis, father            :array[0..10000] of longint;

    flag                        :array[0..10000] of boolean;

     

function min(a,b:longint):longint;

begin

    if a>b then min:=b else min:=a;

end;

     

procedure connect(a,b,c,d:longint);

begin

    inc(l);

    pre[l]:=last[a];

    last[a]:=l;

    other[l]:=b;

    len[l]:=c;

    cost[l]:=d;

end;

     

     

procedure init;

var

    i, j, k                     :longint;

    c                           :char;

    curx, cury                  :longint;

     

begin

    readln(n,m);

    go[1,1]:=-1; go[2,2]:=1;

    go[1,3]:=1; go[2,4]:=-1;

    l:=1;

    for i:=1 to n do

    begin

        for j:=1 to m do

        begin

            read(c);

            if c='U' then map[i,j]:=1 else

            if c='R' then map[i,j]:=2 else

            if c='D' then map[i,j]:=3 else

            if c='L' then map[i,j]:=4;

        end;

        readln;

    end;

    for i:=1 to n do

        for j:=1 to m do num[i,j]:=((i-1)*m+j);

    source:=2*m*n+2; sink:=source+1;

    for i:=1 to n do

        for j:=1 to m do

            for k:=1 to 4 do

            begin

                curx:=i+go[1,k];

                cury:=j+go[2,k];

                if curx=0 then curx:=n; if curx=n+1 then curx:=1;

                if cury=0 then cury:=m; if cury=m+1 then cury:=1;

                if map[i,j]=k then

                begin

                    connect(num[i,j]+n*m,num[curx,cury],1,0);

                    connect(num[curx,cury],num[i,j]+n*m,0,0);

                end else

                begin

                    connect(num[i,j]+n*m,num[curx,cury],1,1);

                    connect(num[curx,cury],num[i,j]+n*m,0,-1);

                end;

            end;

    for i:=1 to n do

        for j:=1 to m do

        begin

            connect(source,num[i,j]+n*m,1,0);

            connect(num[i,j]+n*m,source,0,0);

            connect(num[i,j],sink,1,0);

            connect(sink,num[i,j],0,0);

        end;

    {for i:=1 to n do 

        for j:=1 to m do 

        begin

            connect(num[i,j],num[i,j]+n*m,1,0);

            connect(num[i,j]+n*m,num[i,j],0,0);

        end;}

end;

 

function spfa:boolean;

var

    q, p, cur                   :longint;

    h, t                        :longint;

begin

    filldword(dis,sizeof(dis) div 4,maxlongint div 10);

    h:=0; t:=1;

    que[1]:=source; dis[source]:=0;

    while h<>t do

    begin

        h:=h mod 10000+1;

        cur:=que[h];

        flag[cur]:=false;

        q:=last[cur];

        while q<>0 do

        begin

            p:=other[q];

            if len[q]>0 then

            begin

                if dis[p]>dis[cur]+cost[q] then

                begin

                    dis[p]:=dis[cur]+cost[q];

                    father[p]:=q;

                    if not flag[p] then

                    begin

                        t:=t mod 10000+1;

                        que[t]:=p;

                        flag[p]:=true;

                    end;

                end;

            end;

            q:=pre[q];

        end;

    end;

    if dis[sink]=maxlongint div 10 then exit(false) else exit(true);

end;

 

procedure update;

var

    cur, low                    :longint;

begin

    cur:=sink;

    low:=maxlongint;

    while cur<>source do

    begin

        low:=min(low,len[father[cur]]);

        cur:=other[father[cur] xor 1];

    end;

    cur:=sink;

    while cur<>source do

    begin

        dec(len[father[cur]],low);

        inc(len[father[cur] xor 1],low);

        inc(ans,low*cost[father[cur]]);

        cur:=other[father[cur] xor 1];

    end;

end;

 

procedure main;

begin

    while spfa do

        update;

    writeln(ans);

end;

 

begin

    init;

    main;

end.