[cogs736][网络流24题#13]星际转移[网络流，网络判定]

将一个空间站分为天数个点，每次枚举天数，每增加一天就把对应天数的边连上，用网络流判定可行性，即-判断最大流是否不小于k，注意编号不要错位。通过此题，可见一些网络流题目需要用到网络判定方法，但虽然答案具有单调性，却不适合二份答案，原因有两个：一是网络流题目一般数据规模不会很大，二是网络流题目如果二分就必须每次全部重新建图，而普通枚举可以在上以阶段的图中递推操作，所以往往枚举的效率和代码复杂度更好。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <queue>

using namespace std;

#define    INF    0x3f3f3f3f

template<const int _n>
struct Edge
{
    struct Edge_base { int    to,w,next; }e[_n];
    int    cnt,p[_n];
    Edge() { clear(); }
    void    clear() { cnt=1,memset(p,0,sizeof(p)); }
    int    start(const int x) { return p[x]; }
    Edge_base&    operator[](const int x) { return e[x]; }
    void    insert(const int x,const int y,const int z)
    { e[++cnt].to=y; e[cnt].next=p[x]; e[cnt].w=z; p[x]=cnt; return ; }
};

int    n,m,SSS,TTT,Flow;
int    level[5100],cur[5100],h[5100];
vector<int>    vec[5100];
Edge<210000>    e;

bool    Bfs(const int S)
{
    int    i,t;
    queue<int>    Q;
    memset(level,0,sizeof(level));
    level[S]=1;
    Q.push(S);
    while(!Q.empty())
    {
        t=Q.front(),Q.pop();
        for(i=e.start(t);i;i=e[i].next)
        {
            if(!level[e[i].to] && e[i].w)
            {
                level[e[i].to]=level[t]+1;
                Q.push(e[i].to);
            }
        }
    }
    return level[TTT];
}

int    Dfs(const int S,const int bk)
{
    if(S==TTT)return bk;
    int    rest=bk;
    for(int &i=cur[S];i;i=e[i].next)
    {
        if(level[e[i].to]==level[S]+1 && e[i].w)
        {
            int    flow=Dfs(e[i].to,min(rest,e[i].w));
            e[i].w-=flow;
            e[i^1].w+=flow;
            if((rest-=flow)<=0)break;
        }
    }
    if(rest==bk)level[S]=0;
    return bk-rest;
}

int    Dinic()
{
    while(Bfs(SSS))
    {
        memcpy(cur,e.p,sizeof(cur));
        Flow+=Dfs(SSS,0x3f3f3f3f);
    }
    return Flow;
}

int    P(const int x,const int y)
{
    return y*n+x;
}

int main()
{
    freopen("home.in","r",stdin);
    freopen("home.out","w",stdout);
    int    i,j,t,k,c;

    scanf("%d%d%d",&n,&m,&k);
    for(i=1;i<=m;++i)
    {
        scanf("%d%d",&h[i],&t);
        for(j=1;j<=t;++j)
        {
            scanf("%d",&c);
            if(c==-1)c=n+1;if(c==0)c=n+2;
            vec[i].push_back(c);
            if(j!=1)e.insert(vec[i][j-2],vec[i][j-1],1);
        }
        e.insert(vec[i][t-1],vec[i][0],i);
    }
    
    SSS=n+2,TTT=n+1;
    n+=2;
    int    S=n,T=n-1;
    if(!Bfs(SSS)){printf("0\n");goto End;}

    e.clear();SSS=1000,TTT=SSS+1;
    e.insert(SSS,P(S,0),INF);e.insert(P(S,0),SSS,0);
    e.insert(P(T,0),TTT,INF);e.insert(TTT,P(T,0),0);
    for(i=1;;i++)
    {
        e.insert(SSS,P(S,i),INF);
        e.insert(P(S,i),SSS,0);
        e.insert(P(T,i),TTT,INF);
        e.insert(TTT,P(T,i),0);
        for(j=1;j<=n;++j)
        {
            e.insert(P(j,i-1),P(j,i),INF);
            e.insert(P(j,i),P(j,i-1),0);
        }
        for(j=1;j<=m;++j)
        {
            e.insert(P(vec[j][(i-1)%vec[j].size()],i-1),P(vec[j][i%vec[j].size()],i),h[j]);
            e.insert(P(vec[j][i%vec[j].size()],i),P(vec[j][(i-1)%vec[j].size()],i-1),0);
        }
        if(Dinic()>=k)break;
    }    

    printf("%d\n",i);

End:
    return 0;
}