星际转移问题

P2754 [CTSC1999]家园 / 星际转移问题

分析

这里用到的优化是图论常见的优化，分层图。

我们来分析一下题意，我们想要知道

至少需要花多少天才能够将k个人从0号点送到n+1号点

其中有m条路线，每条路线承载人数是有限的的。

这题还是难想的，我们直接说建图思路。

我们建立节点之间的网络流时候，只能表示人员之间的流动，但并不能表示时间。

当需要考虑时间与人数之间的流动，提示我们构建分层图。

我们将所有的点，多增加一维时间。

这样，我们对这样的图，去跑网络流，就可以加上时间的概念。

因为我们想知道最短的时间能送完所有人。这里可以利用迭代加深的思维。

我们一天天的增加，即为我们一层层增加点，当满足了，就直接break。

至于建边的话，

• 最开始时，只有一层day=0，从S向<0,0>连一条容量为k的边，从<day,0>向汇点连一条容量为无穷的边。
• 每新加一层，我们根据当前层与上一层的天数，确定每条线路连接的边为哪两条两点。同时从<day,n+1>向汇点连一条容量为无穷的边。

AC_code

#include<bits/stdc++.h>

using namespace std;

const int N = 751*15 + 10,M = (N + 751 + 751*22)*2 + 10,INF = 0x3f3f3f3f;

int n,m,k,S,T;
int h[N],e[M],ne[M],f[M],idx;
int cur[N],q[N],d[N];
int p[N];
struct Ship
{
    int h,r,s[15];
}ships[22];

void add(int a,int b,int c)
{
    e[idx] = b,ne[idx] = h[a],f[idx] = c,h[a] = idx++;
    e[idx] = a,ne[idx] = h[b],f[idx] = 0,h[b] = idx++;
}

int get(int i,int day)
{
    return (n + 2)*day + i;
}

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

bool bfs()
{
    int hh = 0,tt = -1;
    memset(d,-1,sizeof d);
    d[S] = 0,cur[S] = h[S],q[++tt] = S;
    while(hh<=tt)
    {
        auto t = q[hh++];
        for(int i=h[t];~i;i=ne[i])
        {
            int j = e[i];
            if(d[j]==-1&&f[i]){
                cur[j] = h[j],d[j] = d[t] + 1;
                if(j==T) return 1;
                q[++tt] = j;
            }
        }
    }
    return 0;
}

int find(int u,int limit)
{
    if(u==T) return limit;
    int flow = 0;
    for(int i=cur[u];~i&&flow<limit;i=ne[i])
    {
        int j = e[i];
        cur[u] = i;
        if(d[j]==d[u]+1&&f[i])
        {
            int t = find(j,min(f[i],limit-flow));
            if(!t) d[j] = -1;
            f[i] -= t,f[i^1] += t,flow += t;
        }
    }
    return flow;
}

int dinic()
{
    int r = 0,flow;
    while(bfs()) if(flow = find(S,INF)) r += flow;
    return r;
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    S = N - 1,T = N - 2;
    memset(h,-1,sizeof h);
    for(int i=0;i<=n+1;i++) p[i] = i;
    for(int i=0;i<m;i++)
    {
        int h,r;scanf("%d%d",&h,&r);
        ships[i] = {h,r};
        for(int j=0;j<r;j++)
        {
            int x;
            scanf("%d",&x);
            if(x==-1) x = n + 1;
            ships[i].s[j] = x;
            if(j)
            {
                int pa = find(ships[i].s[j-1]),pb = find(ships[i].s[j]);
                p[pa] = pb;
            }
        }
    }
    if(find(0)!=find(n+1)) puts("0");
    else 
    {
        add(S,get(0,0),k);
        add(get(n+1,0),T,INF);
        int day = 1,res = 0;
        while(1)
        {
            // cnt++;
            // if(cnt>=10) break;
            add(get(n+1,day),T,INF);
            for(int i=0;i<=n+1;i++) add(get(i,day-1),get(i,day),INF);
            for(int i=0;i<m;i++)
            {
                int r = ships[i].r;
                int a = ships[i].s[(day-1)%r],b = ships[i].s[day%r];
                add(get(a,day-1),get(b,day),ships[i].h);
            }
            res += dinic();
            // cout<<res<<endl;
            if(res>=k) break;
            day++;
        }
        printf("%d\n",day);
    }
    return 0;
}