洛谷2754 [CTSC1999]家园

题目链接：[CTSC1999]家园

这个题目我们不是很好在做网络流的时候判断是否有解，因此我们考虑分开来做

对于是否有解的判断，我们唯一需要解决的是飞船的周期停泊问题，对于这个问题，我们可以用并查集解决

我们记源点(s)是地球，汇点(t)是月球，将一艘飞船上一秒在的星球和下一秒在的星球并入一个集合中，最后判断(s)和(t)是否在同一个集合中即可

对于第二问，我们可以建立分层图。即对于每一秒的飞船情况建立新边，具体的，我们从上一秒飞船所在的地方向下一秒它将去往的地方连边。这样做也是为了求解时间的方便，如果只是简单的网络流建边是无法处理时间的，只能从时间上入手，于是考虑根据时间的推进来模拟行程

同时还要注意：汇点(t)一直不会变，但是由于时间限制，如果以地球为源点的话就与上文求时间的方法产生冲突，故我们对地球也进行分层点即可

#include<iostream>
#include<string>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
using namespace std;
#define maxd 1e9+7
struct node{
    int len,siz,to[60];
}ship[30];
int n,m,k,s=0,t=10005,fa[100100];
struct network_flows{
    struct node{
        int from,to,nxt,flow;
    }sq[100100];
    int all,dep[100100],head[100100],cur[100100],n,m,s,t;
    bool vis[100100];

   void init()
    {
        this->s=0;this->t=10005;this->all=1;
        memset(head,0,sizeof(head));
    }

    void add(int u,int v,int w)
    {
        all++;sq[all].from=u;sq[all].to=v;sq[all].nxt=head[u];sq[all].flow=w;head[u]=all;
        all++;sq[all].from=v;sq[all].to=u;sq[all].nxt=head[v];sq[all].flow=0;head[v]=all;
    }

    bool bfs()
    {
        queue<int> q;int i;
        memset(vis,0,sizeof(vis));
        vis[s]=1;q.push(s);dep[s]=0;
        while (!q.empty())
        {
            int u=q.front();q.pop();
            for (i=head[u];i;i=sq[i].nxt)
            {
                int v=sq[i].to;
                if ((!vis[v]) && (sq[i].flow))
                {
                    vis[v]=1;dep[v]=dep[u]+1;q.push(v);
                }
            }
        }
        if (!vis[t]) return 0;
        //for (i=1;i<=n;i++) cur[i]=head[i];
        return 1;
    }

    int dfs(int now,int to,int lim)
    {
        if ((!lim) || (now==to)) return lim;
        int i,sum=0;
        for (i=head[now];i;i=sq[i].nxt)
        {
            int v=sq[i].to;
            if (dep[now]+1==dep[v])
            {
                int f=dfs(v,to,min(lim,sq[i].flow));
                if (f)
                {
                    lim-=f;sum+=f;
                    sq[i].flow-=f;
                    sq[i^1].flow+=f;
                    if (!lim) break;
                }
            }
        }
        return sum;
    }

    int work()
    {
        int ans=0;
        while (bfs()) ans+=dfs(s,t,maxd);
        return ans;
    }
}dinic;

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;
}

void init()
{
    n=read();m=read();k=read();
    dinic.init();int i,j;
    for (i=1;i<=m;i++)
    {
        ship[i].siz=read();ship[i].len=read();
        for (j=0;j<ship[i].len;j++)
            ship[i].to[j]=read();
    }
}

int find(int x)
{
    if (fa[x]==x) return x;
    fa[x]=find(fa[x]);
    return fa[x];
}

void Union(int x,int y)
{
    int fx=find(x),fy=find(y);
    if (fx!=fy) fa[fx]=fy;
}

bool no_solution()
{
    int i,j;
    for (i=1;i<=n+2;i++) fa[i]=i;
    for (i=1;i<=m;i++)
    {
        for (j=0;j<ship[i].len;j++)
        {
            if (ship[i].to[j]==0) ship[i].to[j]=n+1;
            if (ship[i].to[j]==-1) ship[i].to[j]=n+2;
            if (j>0) Union(ship[i].to[j-1],ship[i].to[j]);
        }
    }
    int fx=find(n+1),fy=find(n+2);
    if (fx!=fy) return 1;else return 0;
}

void work()
{
    if (no_solution()) {printf("0");return;}
    int ans=0,now=0;
    while (1)
    {
        ans++;
        dinic.add(s,(ans-1)*(n+1)+n+1,maxd);
        int i,j;
        for (i=1;i<=m;i++)
        {
            int a=(ans-1)%ship[i].len,b=ans%ship[i].len;
            if (ship[i].to[a]==n+2) a=t;else a=(ans-1)*(n+1)+ship[i].to[a];
            if (ship[i].to[b]==n+2) b=t;else b=ans*(n+1)+ship[i].to[b];
            dinic.add(a,b,ship[i].siz);
        }
        now+=dinic.work();
        if (now>=k) break;
        for (i=1;i<=n+1;i++)
            dinic.add((ans-1)*(n+1)+i,ans*(n+1)+i,maxd);
    }
    printf("%d",ans);
}

int main()
{
    init();
    work();
    return 0;
}