【BZOJ-2502】清理雪道有上下界的网络流（有下界的最小流）

2502: 清理雪道

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 594 Solved: 318
[Submit][Status][Discuss]

Description

滑雪场坐落在FJ省西北部的若干座山上。

从空中鸟瞰，滑雪场可以看作一个有向无环图，每条弧代表一个斜坡（即雪道），弧的方向代表斜坡下降的方向。

你的团队负责每周定时清理雪道。你们拥有一架直升飞机，每次飞行可以从总部带一个人降落到滑雪场的某个地点，然后再飞回总部。从降落的地点出发，这个人可以顺着斜坡向下滑行，并清理他所经过的雪道。

由于每次飞行的耗费是固定的，为了最小化耗费，你想知道如何用最少的飞行次数才能完成清理雪道的任务。

Input

输入文件的第一行包含一个整数n (2 <= n <= 100) – 代表滑雪场的地点的数量。接下来的n行，描述1~n号地点出发的斜坡，第i行的第一个数为m_i (0 <= m_i <n) ，后面共有m_i个整数，由空格隔开，每个整数a_ij互不相同，代表从地点i下降到地点a_ij的斜坡。每个地点至少有一个斜坡与之相连。

Output

输出文件的第一行是一个整数k – 直升飞机的最少飞行次数。

Sample Input

8
1 3
1 7
2 4 5
1 8
1 8
0
2 6 5
0

Sample Output

HINT

Source

2011福建集训

Solution

有下界的最小流

又题很容易看出，每条边的流至少为1，即下界唯一，总流最小，很显然下界为1的最小流无上界或者说上界为inf

不能直接求解，考虑如下：

给每条边加一条下界容量1,一条上界容量inf;

S到各点连边,下界0,上界inf;各点到T连边,下界0,上界inf;

求出最小流就是答案,所以考虑最小流的求法:

添加超级源汇变成无源汇可行流 ,这就需要连T-->S容量为inf, 这样可以得到满足下界的流量FlowSum,但显然不是所求

去掉原来的S,T,再进行一遍得到Flow,最后的答案,即最小流为FlowSum-Flow

自己是这样理解的:

再求可行流的时候,所得的流量并非全在 (T,S)这条直连路径上,而同样可能在T-S之间的路径上,所以显然不是最小

那么再做一遍,可以理解为退流 ,退掉尽可能多的流,由于下界是不会被退掉的,所以差值就是所求最小流

Code

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
int read()
{
    int x=0,f=1; char ch=getchar();
    while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}
    while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
#define maxn 500
#define maxm 1000010
int n,m,ind[maxn],S,SS,T,TT;
struct EdgeNode{int to,next,cap;}edge[maxm];
int head[maxn],cnt=1;
void add(int u,int v,int w)
{
    cnt++;
    edge[cnt].to=v;edge[cnt].cap=w;edge[cnt].next=head[u]; head[u]=cnt;
}
void insert(int u,int v,int w) {add(u,v,w); add(v,u,0);}
int dis[maxn],que[maxn<<1],cur[maxn];
bool bfs()
{
    for (int i=0; i<=T; i++) dis[i]=-1;
    que[0]=S; dis[S]=0; int he=0,ta=1;
    while (he<ta)
        {
            int now=que[he++];
            for (int i=head[now]; i; i=edge[i].next)
                if (edge[i].cap && dis[edge[i].to]==-1)
                    dis[edge[i].to]=dis[now]+1,que[ta++]=edge[i].to;
        }
    return dis[T]!=-1;
}
int dfs(int loc,int low)
{
    if (loc==T) return low;
    int w,used=0;
    for (int i=cur[loc]; i; i=edge[i].next)
        if (edge[i].cap && dis[edge[i].to]==dis[loc]+1)
            {
                w=dfs(edge[i].to,min(low-used,edge[i].cap));
                edge[i].cap-=w; edge[i^1].cap+=w;
                used+=w; if (edge[i].cap) cur[loc]=i;
                if (used==low) return low;
            }
    if (!used) dis[loc]=-1;
    return used;
}
#define inf 0x7fffffff
int dinic()
{
    int tmp=0;
    while (bfs())
        {
            for (int i=0; i<=T; i++) cur[i]=head[i];
            tmp+=dfs(S,inf);
        }
    return tmp;
}
int a[maxn][maxn];
int Work()
{ 
    for (int i=1; i<=n; i++)
        for (int j=1; j<=a[i][0]; j++)
            insert(i,a[i][j],inf),ind[i]--,ind[a[i][j]]++;
    SS=n+1; TT=SS+1; S=TT+1;T=S+1;  
    for(int i=1; i<=n; i++)  
        {  
               insert(SS,i,inf);  
            insert(i,TT,inf);  
            if(ind[i]>0) insert(S,i,ind[i]);  
                else insert(i,T,-ind[i]);  
    }  
    insert(TT,SS,inf); 
    int Flow=0,FlowSum=0;
    Flow=dinic();
    FlowSum=edge[cnt].cap;  
    head[SS]=edge[head[SS]].next;  
    head[TT]=edge[head[TT]].next;  
    for (int i=head[S]; i; i=edge[i].next)  
        edge[i].cap=0,edge[i^1].cap=0;  
    for (int i=head[T]; i; i=edge[i].next)  
        edge[i].cap=0,edge[i^1].cap=0;  
    insert(S,TT,inf);  insert(SS,T,inf);  
    Flow=dinic(); 
    return FlowSum-Flow;  
}
int main()
{
    n=read();
    for (int t,i=1; i<=n; i++)
        {
            a[i][0]=read();
            for (int j=1; j<=a[i][0]; j++)
                a[i][j]=read();
        }
    printf("%d
",Work());
    return 0;
}