网络流24题之十三星际转移问题

内容

填坑

题目描述

由于人类对自然资源的消耗，人们意识到大约在 2300 年之后，地球就不能再居住了。于是在月球上建立了新的绿地，以便在需要时移民。令人意想不到的是，2177 年冬由于未知的原因，地球环境发生了连锁崩溃，人类必须在最短的时间内迁往月球。现有 n 个太空站位于地球与月球之间，且有 m 艘公共交通太空船在其间来回穿梭。每个太空站可容纳无限多的人，而每艘太空船 i 只可容纳 H[i]个人。每艘太空船将周期性地停靠一系列的太空站，例如：(1，3，4)表示该太空船将周期性地停靠太空站 134134134…。每一艘太空船从一个太空站驶往任一太空站耗时均为 1。人们只能在太空船停靠太空站(或月球、地球)时上、下船。初始时所有人全在地球上，太空船全在初始站。试设计一个算法，找出让所有人尽快地全部转移到月球上的运输方案。

对于给定的太空船的信息，找到让所有人尽快地全部转移到月球上的运输方案。

输入输出格式

输入格式：

第 1 行有 3 个正整数 n（太空站个数），m（太空船个数）和 k（需要运送的地球上的人的个数）。其中 1<=m<=13, 1<=n<=20, 1<=k<=50。接下来的 m 行给出太空船的信息。第 i+1 行说明太空船 pi。第 1 个数表示 pi 可容纳的人数 Hpi；第 2 个数表示 pi 一个周期停靠的太空站个数 r，1<=r<=n+2；随后 r 个数是停靠的太空站的编号(Si1,Si2,…,Sir)，地球用 0 表示，月球用-1 表示。时刻 0 时，所有太空船都在初始站，然后开始运行。在时刻 1，2，3…等正点时刻各艘太空船停靠相应的太空站。人只有在 0,1,2…等正点时刻才能上下太空船。

输出格式：

程序运行结束时，将全部人员安全转移所需的时间输出。如果问题

无解，则输出 0。

输入输出样例

输入样例#1：

2 2 1
1 3 0 1 2
1 3 1 2 –1

输出样例#1：

模型：

分层图网络流问题，枚举答案，构造网络流判定。

实现

首先判断从地球到月球是否存在一条路线，如果不存在那么无解，否则把每个太空站按照每天拆分成d个点，<i,d>表示第i个站第d天。建立附加源S汇T，顺序枚举答案Day。

1、对于第Day天，从S到<0,Day>连接一条容量为无穷大的有向边。
2、从<-1,Day>到T连接一条容量为无穷大的有向边。
3、对于第i个太空船，设第Day-1天在a处，第Day天在b处，从<a,Day-1>到<b,Day>连接一条容量为该太空船容量的有向边。
4、对于第i个太空站，从<i,Day-1>到<i,Day>连接一条容量为无穷大的有向边。
5、求当前网络最大流，如果最大流量大于等于地球上人数K，停止枚举，当前Day值就是答案。

分析

我们把网络优化问题转化为枚举答案+可行性判定问题。枚举天数，按天数把图分层，因为乘船每坐一站天数都要增加一，把太空船航线抽象成图中的一条边，跨图的两层。由于太空船容量有限，边上也要加上容量限制。除了坐船以外，人还可以在某个空间站等待下一班太空船的到来，所以每个点要与下一层同一点连接一条容量为无穷的边。这样在层限制的图上求出的网络最大流就是在当前天数以内能够从地面到月球的最多的人数，该人数随天数递增不递减，存在单调性。所以可以枚举答案或二分答案，用网络流判定。网络流判定问题更适合枚举答案，而不是二分，因为新增一些点和边只需要在原有的基础上增广，不必重新求网络流。

代码：

#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
#define M 3000
#define N 1000
#define INF 0x3f3f3f3f
#define min(x,y) ((x<y)?(x):(y))
#define getchar() (S == T && (T = (S = BB) + fread(BB, 1, 1 << 15, stdin), S == T) ? EOF : *S++)
using namespace std;
char BB[1 << 15], *S = BB, *T = BB;
struct UFS
{
    int fa[M];
    void make_set(int m){for (int i=1;i<=m;i++)fa[i]=i;}
    int finds(int x){if (x==fa[x])return x;else return fa[x]=finds(fa[x]);}
    int judge(int x,int y){return finds(x)==finds(y);}
    void merge(int x,int y){fa[finds(x)]=finds(y);}
}ufs;
struct ship
{
    int c,len,p[21];
}Ship[21];
struct node
{
    int from,to,next,flow;
}e[M];
int tot=-1,st[M],dis[N];
int n,m,x,y,z,k,c;
int deep[N],pre[N],num[N],cur[N];
int inline 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 add(int x,int y,int z)
{
    e[++tot].to=y;
    e[tot].from=x;
    e[tot].flow=z;
    e[tot].next=st[x];
    st[x]=tot;
}
void add_edge(int x,int y,int z)
{add(x,y,z),add(y,x,0);}
int bfs(int s,int t)
{
    int now;
    queue<int>que;
    memset(dis,-1,sizeof dis);
    dis[s]=1;
    que.push(s);
    while (!que.empty())
    {
        int now=que.front();
        que.pop();
        for (int i=st[now];~i;i=e[i].next)
            if (dis[e[i].to]<0&&e[i].flow>0)
                dis[e[i].to]=dis[now]+1,
                que.push(e[i].to);
    }
    if (dis[t]>0) return 1;
    return 0;
}
int finds(int x,int y,int low)
{
    int ans;
    if (x==y)
        return low;
    for (int i=st[x];~i;i=e[i].next)
        if (e[i].flow>0 && dis[x]+1==dis[e[i].to] && (ans=finds(e[i].to,y,min(low,e[i].flow))))
        {
            e[i].flow-=ans;
            e[i^1].flow+=ans;
            return ans;
        }
    return 0;
}
int Dinic(int s,int t)
{
    int flow=0;
    while(bfs(s,t))
    {
        while(x=finds(s,t,0x3f3f3f3f))
            flow+=x;
    }
    return flow;
}
int get(int x,int day)
{
    return day*n+x;
}
main()
{
    n=read(),m=read(),k=read();
    int S=0,T=-1;
    memset(e,-1,sizeof e);
    memset(st,-1,sizeof st);
    S=0; T=N-1;
    ufs.make_set(n+2);
    for (int i=1;i<=m;i++)
    {
        Ship[i].c=read(),Ship[i].len=read();
        for (int j=1;j<=Ship[i].len;j++)
        {
            c=read();
            if (c==0)
                c=n+2;
            if (c==-1)
                c=n+1;
            Ship[i].p[j]=c;
            if (j>1)
                ufs.merge(Ship[i].p[j-1],c);
        }
    }
    n+=2;
    if (!ufs.judge(n-1,n))
    {
        puts("0");
        return 0;
    }
    int FLOW=0,Day;
    add_edge(S,get(n,0),INF);
    add_edge(get(n-1,0),T,INF);
    for (Day=1;FLOW<k;Day++)
    {
        add_edge(S,get(n,Day),INF);
        add_edge(get(n-1,Day),T,INF);
        for (int i=1;i<=n;i++)
            add_edge(get(i,Day-1),get(i,Day),INF);
        for (int i=1;i<=m;i++)
        {
            x=Ship[i].p[(Day-1)%Ship[i].len+1];
            y=Ship[i].p[Day%Ship[i].len+1];
            add_edge(get(x,Day-1),get(y,Day),Ship[i].c);
        }
        FLOW+=Dinic(S,T);
    }
    printf("%d",Day-1);
//  for (int i=1;i<=m;i++)
//      x=read(),y=read(),z=read(),add_edge(x,y,z);
//  printf("%d\n",ISAP(S,T));
}

网络流24题之十三 星际转移问题

题目描述

输入输出格式

输入输出样例

网络流24题之十三星际转移问题