uva 12125 - March of the Penguins（最大流）

Problem B - March of the Penguins

Time limit: 4 seconds

Somewhere near the south pole, a number of penguins are standing on a number of ice floes. Being social animals, the penguins would like to get together, all on the same floe. The penguins do not want to get wet, so they have use their limited jump distance to get together by jumping from piece to piece. However, temperatures have been high lately, and the floes are showing cracks, and they get damaged further by the force needed to jump to another floe. Fortunately the penguins are real experts on cracking ice floes, and know exactly how many times a penguin can jump off each floe before it disintegrates and disappears. Landing on an ice floe does not damage it. You have to help the penguins find all floes where they can meet.

A sample layout of ice floes with 3 penguins on them.

Input

On the first line one positive number: the number of testcases, at most 100. After that per testcase:

• One line with the integer N (1 ≤ N ≤ 100) and a floating-point number D (0 ≤ D ≤ 100000), denoting the number of ice pieces and the maximum distance a penguin can jump.
• N lines, each line containing x_i, y_i, n_i and m_i, denoting for each ice piece its X and Y coordinate, the number of penguins on it and the maximum number of times a penguin can jump off this piece before it disappears (-10000 ≤ x_i, y_i ≤ 10000, 0 ≤ n_i ≤ 10, 1 ≤ m_i ≤ 200).

Output

Per testcase:

• One line containing a space-separated list of 0-based indices of the pieces on which all penguins can meet. If no such piece exists, output a line with the single number -1.

Sample Input

2
5 3.5
1 1 1 1
2 3 0 1
3 5 1 1
5 1 1 1
5 4 0 1
3 1.1
-1 0 5 10
0 0 3 9
2 0 1 1

Sample Output

1 2 4
-1

The 2007 ACM Northwestern European Programming Contest

 

有节点容量的最大流。把每个点拆成两个点，中间连一条容量为节点容量的边即可。

所有点均可能是汇点，所以一一枚举。注意：每次枚举前记得把图中的流量清0。

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn = 202 + 10;
const int INF = 1000000000;

struct Edge {
  int from, to, cap, flow;
};

struct Dinic {
  int n, m, s, t;
  vector<Edge> edges;    // 边数的两倍
  vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
  bool vis[maxn];        // BFS使用
  int d[maxn];           // 从起点到i的距离
  int cur[maxn];         // 当前弧指针

  void ClearAll(int n) {
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
  }

  void ClearFlow() {
    for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
  }

  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);
    vis[s] = 1;
    d[s] = 0;
    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;
    for(int& i = cur[x]; i < G[x].size(); 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;
  }
};

struct Node{
    int x,y,num;
}p[maxn];

Dinic g;

double dis(Node a,Node b){
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
vector<int> ans;

int main(){
    int t,n,total;
    double D;
    scanf("%d",&t);
    while(t--){
        scanf("%d%lf",&n,&D);
        g.ClearAll(2*n+1);
        int sorce = 0;
        total = 0;D = D*D;
        for(int i = 1;i <= n;i++){
            int x,y,ni,cap;
            scanf("%d%d%d%d",&x,&y,&ni,&cap);
            p[i].x = x;p[i].y = y;p[i].num = ni;
            total += ni;
            g.AddEdge(sorce,i,ni);
            g.AddEdge(i,i+n,cap);
        }
        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= n;j++){
                if(i != j && D-dis(p[i],p[j])> 1e-6){
                    g.AddEdge(i+n,j,INF);
                }
            }
        }
        int sum = 0;
        ans.clear();
        for(int i = 1;i <= n;i++){
            g.ClearFlow();
            if(g.Maxflow(sorce,i) == total){
                ans.push_back(i);
                sum++;
            }
        }
        if(sum == 0)    printf("-1\n");
        else{
            for(int i = 0;i < ans.size()-1;i++)
                printf("%d ",ans[i]-1);
            printf("%d\n",ans[ans.size()-1]-1);
        }
    }
    return 0;
}