poj 3498 March of the Penguins

题意： 在二维平面上有n块浮冰，有些上面有企鹅，给出企鹅的跳跃能力（欧式距离），每块冰有一个可以承受的跳跃次数，给出每块冰的坐标，上面的企鹅数量和可以承受的跳跃次数，问哪些冰块可以作为企鹅的汇合点（冰块下标从0开始

思路： 就一拆点裸题，源点向每个有企鹅的冰连一条容量为企鹅数的边，两两能到的冰连边，冰拆点，容量为起跳次数，枚举汇点

刚开始T了，然后一度怀疑板子是不是出了问题，后来想也许是我用0开始的下标然后边界出问题了，改成1开始最后答案再减，好家伙，样例过不去了，才发现是初始化少初始了一半的点（ 初始化杀人石锤qwq

我做题的网站就给了1s，poj8s，然后网站没有G++之类的（虽然我至今不知道C++和G++有啥区别，但是跑出来时间好像就是不太一样（
poj最后G++是0.8s过的，还挺充裕（…

你可长点脑子8，juraws

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
typedef long long ll;

struct Edge {
    int from, to, cap, flow;
    Edge(int a, int b, int c, int d) : from(a), to(b), cap(c), flow(d) {}
};

struct Dinic {
    static const int maxn = 210;
    static const int inf = 1e9;
    int N, M, S, T;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        M = edges.size();
        G[from].push_back(M - 2);
        G[to].push_back(M - 1);
    }

    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(S);
        d[S] = 0;
        vis[S] = 1;
        while (!Q.empty()) {
            int x = Q.front();
            Q.pop();
            for (int i = 0; i < G[x].size(); i++) {
                Edge& e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[T];
    }

    int DFS(int x, int a) {
        if (x == T || a == 0) return a;
        int flow = 0, f;
        int siz = G[x].size();
        for (int& i = cur[x]; i < siz; i++) {
            Edge& e = edges[G[x][i]];
            if (d[x] + 1 == d[e.to] &&
                (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (a == 0) break;
            }
        }
        return flow;
    }

    int Maxflow(int S, int T) {
        this->S = S, this->T = T;
        int flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(S, inf);
        }
        return flow;
    }
    
    void clear(int n) {
    	edges.clear();
    	for(int i = 0; i <= 2 * n + 5; ++ i) G[i].clear();
	}
	
	void goback() {
		int siz = edges.size();
		for(int i = 0; i < siz; ++ i) {
			edges[i].flow = 0;
		} 
	}
	
	void db() {
		int siz = edges.size();
		for(int i = 0; i < siz; ++ i) {
			cout << edges[i].from << " " << edges[i].to << " " << edges[i].flow << endl; 
		}
	}
} MF;

const int N = 110;
const int inf = 1e9;

struct node {
	double x, y;
	int n, m;
} mp[N];

inline bool dis(int a, int b, double d) {
	if((mp[a].x - mp[b].x) * (mp[a].x - mp[b].x) 
		+ (mp[a].y - mp[b].y) * (mp[a].y - mp[b].y) <= d * d + 1e-8) return 1;
	return 0; 
}

int main() {
#ifdef ONLINE_JUDGE
#else 
//	freopen("in.txt", "r", stdin);
#endif
// 	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	int T;
    scanf("%d", &T);
	while(T--) {
		
		int n;
		
		double d;
        scanf("%d%lf", &n, &d);
        
		int s = 2 * n + 1;
		int tot = 0;
		for(int i = 1; i <= n; ++ i) {
            scanf("%lf%lf%d%d", &mp[i].x, &mp[i].y, &mp[i].n, &mp[i].m);
			MF.AddEdge(i, i + n, mp[i].m);
			if(mp[i].n > 0) {
				MF.AddEdge(s, i, mp[i].n);
			}
			tot += mp[i].n;
		}
		
		for(int i = 1; i <= n; ++ i) {
			for(int j = 1; j < i; ++ j) {
				if(dis(i, j, d)) {
					MF.AddEdge(i + n, j, inf);
					MF.AddEdge(j + n, i, inf);
				}
			}
		}
		
		vector<int> aa; aa.clear();
		bool flag = 0;
		for(int t = 1; t <= n; ++ t) {
			int res = MF.Maxflow(s, t);
			if(res == tot) {
				//printf("%d ", t);
				aa.push_back(t);
				flag = 1;	
//				MF.db();
			}
			MF.goback();
		}
		if(flag) {
			int siz = aa.size();
			for(int i = 0; i < siz; ++ i) {
				if(i != 0) cout << " ";
				cout << aa[i] - 1;
			}
		}
		if(!flag) printf("-1");
		printf("\n"); 
		
		MF.clear(n);
	}
	
	return 0;
}