sgu 438 The Glorious Karlutka River =)（动态网络流）

题意：m个人在一条宽度为w的河的南岸，现在要到对岸，已知河中有n块石头，每块石头同时只能容纳ci个人，每个人一次都可以跳向距离为d的距离，每次跳跃耗时为1，问m个人全部过河所要花费的最少时间。

解法：不难看出此题具有网络流的各个因素。源-南岸，汇-北岸，中间点-石头，边-距离小于d的石头之间的连线，费用-1，但是m个人可以分多次过河且可以在中间节点停留，因此不可用费用流解法。由于不同时刻两点之间的流量不同，因此不能用一个网络表示整个过程。

动态流的两个基本问题是：“给出时间限制求最大流量”和“给出流量，求从源到汇输送的最小时间”，对于此类问题，我们需要建立封层网络，随着时间的推移在网络中添加新边，在残余网络中继续寻找增广路求解增加流量，由于如存在方案则最多m+n时间内完成，因此只需枚举时间，逐层添加网络来求解最小时间。因为流量限制在点上而不在边上，因此要通过拆点控制每个点的流量限制。

构图：对于时间k增加的网络：如果点i到南岸的距离小于等于d，则连(S，in(i,k)，inf)，如果i到北岸的距离小于等于d(out(i,k),T,inf)，如果i和j距离小于d则连(out(i,k),in(j,k+1),inf)表示从t-1到t时刻的流量变化，边没有流量限制；连(in(i,k),out(i,k),c[i])限制每个时刻每块石头上最大流量。

import java.util.Arrays;
import java.util.Scanner;
public class River438 {
	int inf = 1<<28,maxn=10110,maxm=550010;
	class Sap {
		class node {
			int be, ne;
			int cap, flow;
			node(int be, int ne, int cap) {
				this.be = be;
				this.ne = ne;
				this.cap = cap;
			}
		}
		int E[]=new int[maxn], len,n;
		int h[]=new int[maxn], vh[]=new int[maxn], s, t;
		node buf[]=new node[maxm];
		void init(int n) {
			this.n=n;
			len = 0;
			Arrays.fill(E, -1);
		}
		void addcap(int i, int j, int cap1, int cap2) {
			buf[len] = new node(j, E[i], cap1);
			E[i] = len++;
			buf[len] = new node(i, E[j], cap2);
			E[j] = len++;
		}
		int sap(int index, int maxcap) {
			if (index == t)
				return maxcap;
			int k = maxcap, d, minh = n;
			// 此次残余流量，某次使用流量，邻居的最小流量
			for (int i = E[index]; i != -1; i = buf[i].ne) {
				node no = buf[i];
				if (no.cap - no.flow > 0) {
					if (h[index] == h[no.be] + 1) {
						d = sap(no.be, Math.min(k, no.cap - no.flow));
						// 下次找到的流量
						no.flow += d;
						buf[i ^ 1].flow -= d;// 记录流量变化
						k -= d;
						if (h[s] == n || k == 0)// GAP
							return maxcap - k;
					}
					minh = Math.min(minh, h[no.be] + 1);// 更新h[index]
				}
			}
			if (k == maxcap) {// 没有找到增广路
				vh[minh]++;
				vh[h[index]]--;
				if (vh[h[index]] == 0)
					h[s] = n;
				h[index] = minh;
			}
			return maxcap - k;
		}
		int solve(int s, int t) {
			if (s == t)
				return inf;
			this.s = s;this.t = t;
			Arrays.fill(h, 0);
			Arrays.fill(vh, 0);
//			for (int i = 0; i < len; i++)
//				buf[i].flow = 0;
			int ans = 0;
			while (h[s] != n)
				ans += sap(s, inf);
			return ans;
		}
		
	}
	Sap sp=new Sap();
	boolean near(int i,int j){
		if(i==j)
			return false;
		return d*d>=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
	}
	int x[]=new int[maxn],y[]=new int[maxn],c[]=new int[maxn];
	Scanner scan=new Scanner(System.in);
	int n,m,d,w,s=10001,t=10002;
	void run(){
		n=scan.nextInt();
		m=scan.nextInt();
		d=scan.nextInt();
		w=scan.nextInt();
		for(int i=1;i<=n;i++)
		{
			x[i]=scan.nextInt();
			y[i]=scan.nextInt();
			c[i]=scan.nextInt();
		}
		if(d>=w){
			System.out.println(1);
			return;
		}
		sp.init(2);
		int cnt=0,i;
		for(i=1;i<=m+n;i++)
		{
			build(i);
			cnt+=sp.solve(s,t);
			if(cnt>=m)
				break;
		}
		if(cnt>=m)
			System.out.println(i+1);
		else
			System.out.println("IMPOSSIBLE");
	}
	int in(int i,int t){
		t--;
		return t*n*2+i;
	}
	int out(int i,int t){
		t--;
		return t*n*2+i+n;
	}
	void build(int k){
		sp.n+=n*2;
		for(int i=1;i<=n;i++){
			if(y[i]<=d)
				sp.addcap(s,in(i,k),m,0);
			if(y[i]+d>=w)
				sp.addcap(out(i,k),t,m,0);
			sp.addcap(in(i,k),out(i,k),c[i],0);
			for(int j=1;j<=n;j++)
				if(near(i,j))
					sp.addcap(out(i,k),in(j,k+1),m,0);
		}
	}
	public static void main(String[] args) {
		new River438().run();
	}
}