bzoj1189

初看这题好像跟我mincost第一题很像，多了点门其实最短路/bfs与处理一下就可以了

但是门只能容纳一个人

所以，也就是说，费用是变的，怎么做？

仔细想想，费用流好像不能处理费用改变的

扔掉费用流，首先决策具有单调性，二分！

当我们确定了时间之后，我们怎么快速的判断可行呢？

由于门每分钟只能容纳一个人，也就是说，在这分钟内这个门只能被一个人匹配

不禁想到了最大流/二分图匹配，暴力将每个门拆成对应时间点

每个人对应能走的门连边然后匈牙利即可

到这问题好像解决了（实际上也解决了）；

但我写着写着发现一个问题

一开始的预处理，似乎不能简单的求每点到每个门的最短距离

因为看起来有的门能到，实际却到不了

比如

XXDDX

XXX.X

X...X

X...X

XXXXX

比如（1,3）的门是根本走不到的，被另一个门挡住了

而且这是会影响结果的（在一个门被堵住，肯定要分流去另一个门）

但我也没管，后来发现数据里好像也没这种情况（……）

就这样吧

一般的，费用流的费用都是不变的吧，否则都应该转化为二分+最大流判定吧

为了方便我写了二分图匹配快一些

const dx:array[1..4] of integer=(0,0,-1,1);
      dy:array[1..4] of integer=(1,-1,0,0);
      inf=10000007;
type node=record
       point,next:longint;
     end;

var a,map,dis:array[0..1010,0..1010] of longint;
    q:array[0..2000010] of longint;
    cx,d,p,b:array[0..1010] of longint;    
    cy:array[0..1001000] of longint;     //注意二分图另一个点集规模
    edge:array[0..5000010] of node;
    v:array[0..1001010] of boolean;
    k,ans,len,pep,sum,x,y,l,r,mid,n,m,t,i,j:longint;
    ch:char;

procedure add(x,y:longint);
  begin
    inc(len);
    edge[len].point:=y;
    edge[len].next:=p[x];
    p[x]:=len;
  end;

procedure spfa(k:longint);
  var s,i,x,f,r:longint;
  begin
    f:=1;
    r:=1;
    for i:=1 to t do
      d[i]:=inf;
    s:=b[k];
    d[s]:=0;
    fillchar(v,sizeof(v),false);
    v[s]:=true;
    q[1]:=s;
    while f<=r do
    begin
      x:=q[f];
      v[x]:=false;
      for i:=1 to t do
        if map[x,i]>0 then
          if d[i]>d[x]+map[x,i] then
          begin
            d[i]:=d[x]+map[x,i];
            if not v[i] then
            begin
              inc(r);
              q[r]:=i;
              v[i]:=true;
            end;
          end;
      inc(f);
    end;
    for i:=1 to pep do
      dis[i,k]:=d[i];
  end;

function dfs(x:longint):boolean;
  var i,j:longint;
  begin
    i:=p[x];
    while i<>-1 do
    begin
      j:=edge[i].point;
      if not v[j] then
      begin
        v[j]:=true;
        if (cy[j]=-1) or dfs(cy[j]) then
        begin
          cy[j]:=x;
          cx[x]:=j;
          exit(true);
        end;
      end;
      i:=edge[i].next;
    end;
    exit(false);
  end;

function check(k:longint):boolean;
  var s,i,j,w,z:longint;
  begin
    len:=0;
    fillchar(p,sizeof(p),255);
    for i:=1 to pep do
    begin
      for j:=1 to sum do
        if dis[i,j]<=k then
        begin
          for w:=0 to k-dis[i,j] do
          begin
            z:=(j-1)*k+dis[i,j]+w;        //暴力拆点
            add(i,z);
          end;
        end;
    end;
    fillchar(cx,sizeof(cx),255);
    fillchar(cy,sizeof(cy),255);
    for i:=1 to pep do
    begin
      fillchar(v,sizeof(v),false);
      if not dfs(i) then exit(false);     //匹配
    end;
    exit(true);
  end;

begin
  readln(n,m);
  fillchar(a,sizeof(a),0);
  for i:=1 to n do
  begin
    for j:=1 to m do
    begin
      read(ch);
      if ch='.' then
      begin
        inc(pep);
        a[i,j]:=pep;
      end
      else if ch='D' then
      begin
        inc(sum);
        a[i,j]:=-sum;
      end;
    end;
    readln;
  end;
  sum:=0;
  for i:=1 to n do
    for j:=1 to m do
      if a[i,j]<0 then
      begin
        inc(sum);
        a[i,j]:=abs(a[i,j])+pep;
        b[sum]:=a[i,j];
      end;

  for i:=1 to n do                  //其实是有问题的预处理
    for j:=1 to m do
      if a[i,j]>0 then
      begin
        for k:=1 to 4 do
        begin
          x:=i+dx[k];
          y:=j+dy[k];
          if a[x,y]>0 then
          begin
            map[a[i,j],a[x,y]]:=1;
            map[a[i,j],a[x,y]]:=1;
          end;
        end;
      end;
  t:=pep+sum;

  for i:=1 to sum do
    spfa(i);                   
  l:=1;
  r:=1000;
  ans:=0;
  while l<=r do
  begin
    mid:=(l+r) shr 1;
    if check(mid) then
    begin
      ans:=mid;
      r:=mid-1;
    end
    else l:=mid+1;
  end;
  if ans=0 then writeln('impossible')
  else writeln(ans);
end.