bzoj2502

学到很多知识的一道题目
一开始读错题，后来发现是每条边必须至少访问一次
明显是一个有下界的最小流
首先是我自己脑补的比较渣的算法，可以无视：
对于有下界的最小流，我不会做，但是我会做有下界的费用流，而且注意这是一个DAG图
只要对每条边建x-->y （flow=1 cost=-inf）和x-->y (flow=inf cost=0)这样两条边
（这是解决DAG图的有下界费用流的非常简便的做法，通过附加边，根据最短路原理一定能保证这条边下界流量被流过）
然后从源点到每个出度非0的点连一条cost=1 flow=inf的边，出度为0的点到汇点连边flow=inf cost=0
然后跑最小费用流（注意这里并不是最大流，只要增广到正费用，就代表原图的边都被走过了，可以直接退出）
最后再加上m*inf即是ans
但是很可惜，这个方法虽然容易想，但是跑得慢（1100ms) 而最优的解法是8ms，差距啊……
本着精益求精的精神，下面介绍有下界的网络流
首先这是一个有源有汇的有下界最小流，要想解决这个问题，就先要解决无源无汇有下界的可行流（循环流）
无源无汇是什么意思呢，那就表示每个点的出流=入流
令每条边上界为a，下界为b，则这样
我们考虑将有下界转化为下界为0的网络流，这样原来每条边的上界变成a-b
但经过这样更改流量是不守恒的，因此，我们添加源汇为s,t
令d(u）=该点入下界流和-该点出下界流和
如果d(u)>0 则连边s-->u flow=d(u)
如果d(u)<0 则连边u-->t flow=-d(u)
不难发现，如果要流量满足下界，那必然s延伸出的附加边一定是满流，这是有附加边流量的意义决定的
因此我们只要做s到t的最大流，然后判断s延伸出的附加边是否满流
如果满流，则存在循环流，如果不存在，那就无解
有了这个基础，我们就不难解决有源有汇的有上下界最大流的问题
首先先转化为已知问题，添加t-->s下界为0，上界为inf的边
这样就转化为无源无汇有下界的可行流，先按上述方法添加超级源汇ss，tt
然后判断是否存在可行流，存在则记为f1
然后再跑s-->t的最大流（这里是改造后的图，即每条边下界为0，上界为a-b）记为f2，
UPD:注意，这里最大流不是f1+f2而是单独的f2，为什么呢？
其实我们在跑完可行流之后，有些边的反向弧存了可行流的流量，这些反向弧可以构成s-->t流量为可行流的路径
所以f2实际上是包含可行流的，具体画一个图就明白了
容易出问题的是有源有汇的有上下界最小流
一开始很容易误认为，添加t-->s下界为0，上界为inf的边，做出来的可行流不就是最小流吗？
实际上是不对的，具体见http://www.cnblogs.com/kane0526/archive/2013/04/05/3001108.html
（注意那张图1--tt之间的边方向似乎反了）
可以发现，当出现循环流的时候，可行流会增大。
因此正确的做法是先不添加t-->s，直接按无源无汇有下界可行流做
然后再添加t-->s，然后再做ss到tt的最大流，如果附加边满流即有解，解就是t-->s实际流过的流量
这应该怎么理解呢?其实第一次做最大流就是在消去循环会带来增加的流量
好再回到这道题目上来，由于这道题目一定有解，而且源点，汇点所连的边下界为0
我们可以稍稍变动一下算法，具体见程序

const inf=10000;
type node=record
       next,point,flow,cost:longint;
     end;

var edge:array[0..400010] of node;
    q:array[0..400010] of longint;
    p,d,pre,cur:array[0..200] of longint;
    v:array[0..200] of boolean;
    s,i,len,n,t,j,x,m:longint;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

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

function spfa:boolean;
  var y,i,f,r,x:longint;
  begin
    d[0]:=0;
    for i:=1 to t do
      d[i]:=inf;
    f:=1;
    r:=1;
    q[1]:=0;
    fillchar(v,sizeof(v),false);
    v[0]:=true;
    while f<=r do
    begin
      x:=q[f];
      v[x]:=false;
      i:=p[x];
      while i<>-1 do
      begin
        y:=edge[i].point;
        if edge[i].flow>0 then
          if d[y]>d[x]+edge[i].cost then
          begin
            d[y]:=d[x]+edge[i].cost;
            pre[y]:=x;
            cur[y]:=i;
            if not v[y] then
            begin
              inc(r);
              q[r]:=y;
              v[y]:=true;
            end;
          end;
        i:=edge[i].next;
      end;
      inc(f);
    end;
    if d[t]=inf then exit(false) else exit(true);
  end;

function mincost:longint;
  var i,j:longint;
  begin
    mincost:=0;
    while spfa do
    begin
      if d[t]>0 then exit;  //关键
      i:=t;
      while i<>0 do
      begin
        j:=cur[i];
        dec(edge[j].flow);
        inc(edge[j xor 1].flow);
        i:=pre[i];
      end;
      mincost:=mincost+d[t];
    end;
  end;

begin
  len:=-1;
  fillchar(p,sizeof(p),255);
  readln(n);
  t:=n+1;
  for i:=1 to n do
  begin
    read(s);
    m:=m+s;
    for j:=1 to s do
    begin
      read(x);
      add(i,x,1,-inf);
      add(x,i,0,inf);
      add(i,x,inf,0);
      add(x,i,0,0);
    end;
    if s=0 then
    begin
      add(i,t,inf,0);
      add(t,i,0,0);
    end
    else begin
      add(0,i,inf,1);
      add(i,0,0,-1);
    end;
  end;
  writeln(mincost+m*inf);
end.

const inf=100007;
type node=record
       next,point,flow:longint;
     end;

var edge:array[0..400010] of node;
    p,d,pre,cur,numh,h,c:array[0..200] of longint;
    v:array[0..200] of boolean;
    s,i,len,n,t,j,x,m:longint;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

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

function sap:longint;
  var i,q,tmp,u,j,neck:longint;
  begin
    neck:=inf;
    for i:=0 to t do
      cur[i]:=p[i];
    numh[0]:=t+1;
    u:=0;
    sap:=0;
    while h[0]<t+1 do
    begin
      d[u]:=neck;
      i:=cur[u];
      while i<>-1 do
      begin
        j:=edge[i].point;
        if (edge[i].flow>0) and (h[u]=h[j]+1) then
        begin
          pre[j]:=u;
          cur[u]:=i;
          neck:=min(neck,edge[i].flow);
          u:=j;
          if u=t then
          begin
            sap:=sap+neck;
            while u<>0 do
            begin
              u:=pre[u];
              j:=cur[u];
              dec(edge[j].flow,neck);
              inc(edge[j xor 1].flow,neck);
            end;
            neck:=inf;
          end;
          break;
        end;
        i:=edge[i].next;
      end;
      if i=-1 then
      begin
        dec(numh[h[u]]);
        if numh[h[u]]=0 then exit;
        tmp:=t;
        q:=-1;
        i:=p[u];
        while i<>-1 do
        begin
          j:=edge[i].point;
          if edge[i].flow>0 then
            if h[j]<tmp then
            begin
              tmp:=h[j];
              q:=i;
            end;
          i:=edge[i].next;
        end;
        cur[u]:=q;
        h[u]:=tmp+1;
        inc(numh[h[u]]);
        if u<>0 then
        begin
          u:=pre[u];
          neck:=d[u];
        end;
      end;
    end;
  end;

begin
  len:=-1;
  fillchar(p,sizeof(p),255);
  readln(n);
  t:=n+1;
  for i:=1 to n do
  begin
    read(s);
    for j:=1 to s do
    begin
      read(x);
      add(i,x,inf);
      add(x,i,0);
      inc(c[x]);
      dec(c[i]);
    end;
  end;
  for i:=1 to n do
    if c[i]>0 then
    begin
      m:=m+c[i];
      add(0,i,c[i]);
      add(i,0,0);
    end
    else if c[i]<0 then
    begin
      add(i,t,-c[i]);
      add(t,i,0);
    end;

  writeln(m-sap);  //一定有解的时候只用跑一次，想想看为什么
end.