sgu 438 The Glorious Karlutka River 【网络流 分层】

链接：http://acm.sgu.ru/problem.php?contest=0&problem=438

题意：有m个人要过河，但是没有桥，他们只能跳到河中的垃圾堆上过河，共有n个垃圾堆，每次只能跳到距离他们不超过D的垃圾上，每个垃圾有人数限制，每次跳跃花费一秒。

问全都过河需要多少秒时间。

分析：我们可以知道要么到不了，要么时间不超过n+m。如果时间只有1秒，那么我们就可以很简单的用网络流判断是否满流即可，这里我们可以将时间拆开，将图分层，一层一层的跑网络流。

假设当前t秒，那么s（河岸既是源）连向第t层的能到的点，这时s可以看成t-1层的点，ed（汇）为t层的点，同理其他第t-1层的点都连向能到的第t层的点，容量都为INF。还有就是每个点也要拆点，表示垃圾堆的容量。

代码：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<cmath>
#include<stack>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define Mn 11010
#define Mm 2000005
#define mod 1000000007
#define CLR(a,b) memset((a),(b),sizeof((a)))
#define CLRS(a,b,Size) memset((a),(b),sizeof((a[0]))*(Size+1))
#define CPY(a,b) memcpy ((a), (b), sizeof((a)))
#pragma comment(linker, "/STACK:102400000,102400000")
#define ul u<<1
#define ur (u<<1)|1
using namespace std;
typedef long long ll;
struct edge {
    int v,w,next;
} e[Mm];
struct point {
    int x,y,w;
}p[Mn];
int deep[Mn];
int head[Mn];
int cur[Mn];
int N,tot;
void addedge(int u,int v,int w) {
    e[tot].v=v;
    e[tot].w=w;
    e[tot].next=head[u];
    head[u]=tot++;
}
queue<int> q;
bool bfs(int st,int en) {
    while(!q.empty()) q.pop();
    CLR(deep,-1);
    q.push(st);
    deep[st]=0;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        if(u==en) return true;
        for(int i=head[u]; i!=-1; i=e[i].next) {
            int v=e[i].v;
            int w=e[i].w;
            if(w>0&&deep[v]==-1) {
                deep[v]=deep[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}
int dfs(int u,int sum,int en) {
    if(u==en) return sum;
    int a=0,us=0;
    for(int &i=cur[u]; i!=-1; i=e[i].next) {
        if(deep[e[i].v]==deep[u]+1) {
            a=sum-us;
            a=dfs(e[i].v,min(a,e[i].w),en);
            e[i].w-=a;
            e[i^1].w+=a;
            if(e[i].w) cur[u]=i;
            us+=a;
            if(us==sum) return sum;
        }
    }
    if(!us) deep[u]=-1;
    return us;
}
int dinic(int st,int en) {
    int ans=0;
    while(bfs(st,en)) {
        CPY(cur,head);
        ans+=dfs(st,INF,en);
    }
    return ans;
}
void init() {
    tot=0;
    CLR(head,-1);
}
vector<int>g[55];
int getdis(int i,int j) {
    return (p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y);
}
int n,m,d,w;
int in(int v,int t) {return t*2*n+v;}
int out(int v,int t) {return (t*2+1)*n+v;}
int s,ed;
void build(int t) {
    for(auto v:g[s]) {
        addedge(s,in(v,t),INF);
        addedge(in(v,t),s,0);
    }
    for(int i=1;i<=n;i++) {
        addedge(in(i,t),out(i,t),p[i].w);
        addedge(out(i,t),in(i,t),0);
    }
    for(int i=1;i<=n;i++) {
        for(auto v:g[i]) {
            addedge(out(i,t-1),in(v,t),INF);
            addedge(in(v,t),out(i,t-1),0);
        }
    }
    for(auto v:g[n+1]) {
        addedge(out(v,t-1),ed,INF);
        addedge(ed,out(v,t-1),0);
    }
}
int main() {
    init();
    scanf("%d%d%d%d",&n,&m,&d,&w);
    for(int i=1;i<=n;i++) {
        scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].w);
    }
    if(m==0) {
        printf("0\n");
        return 0;
    }
    if(w<=d) {
        printf("1\n");
        return 0;
    }
    for(int i=1;i<=n;i++) {
        if(p[i].y<=d) g[0].push_back(i);
        if(p[i].y+d>=w) g[n+1].push_back(i);
        for(int j=i+1;j<=n;j++) {
            if(getdis(i,j)<=d*d) {
                g[i].push_back(j);
                g[j].push_back(i);
            }
        }
    }
    if(g[n+1].size()==0) {
       printf("IMPOSSIBLE\n");
       return 0;
    }
    s=0,ed=2*(n+m+1)*n+1;
    int sum=0;
    for(int i=1;i<=n+m;i++) {
        build(i);
        sum+=dinic(s,ed);
        if(sum>=m) {
            printf("%d\n",i);
            return 0;
        }
    }
    printf("IMPOSSIBLE\n");
    return 0;
}