HDU 4494 - Teamwork(最大流)

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=4494

题意：

n个任务，m种人，给出起点，以及n-1个点的 坐标，任务的开始时间，持续时间，以及每种人需要的人数。同一个人可以完成多种任务，但必须在开始时间之前到达，求出完成所有的任务最少需要多少人。

思路：

建立源点s，汇点t，拆点i，i+n，可以将人转移的两个任务连边（i，j+n），跑最大流，则而已求出可以多次利用的人的最大数量max。答案为所需总人数减去max。

有多种人，则每一种人跑一次最大流。

AC.

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f;
const int maxn = 200;
const int maxv = 5e4;

int n, m;
bool g[maxn][maxn];

struct Node {
    double x, y, b, t;
    int num[10];
    bool operator < (const Node &A) const {
        return b < A.b;
    }
}node[maxn];

struct edge {
    int to, cap, rev;
    edge(int t, int c, int r) {
        to = t; cap = c; rev = r;
    }
};
vector<edge> G[2*maxn];
bool used[2*maxn];

void addedge(int from, int to, int cap)
{
    G[from].push_back(edge(to, cap, G[to].size()));
    G[to].push_back(edge(from, 0, G[from].size()-1));
}

int dfs(int v, int t, int f)
{
    if(v == t) return f;
    used[v] = true;
    for(int i = 0; i < G[v].size(); ++i) {
        edge &e = G[v][i];
        if(!used[e.to] && e.cap > 0) {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t)
{
    int flow = 0;
    while(1) {
        memset(used, 0, sizeof(used));
        int f = dfs(s, t, INF);
        if(f == 0) return flow;
        flow += f;
    }
}

double cal(Node a, Node b)
{
    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}

void build(int s, int t, int id)
{
    for(int i = 0; i <= 2*n+1; ++i) {
        G[i].clear();
    }

    for(int i = 1; i < n; ++i) {
        addedge(s, i, node[i].num[id]);
        addedge(i+n, t, node[i].num[id]);
    }

    for(int i = 1; i < n; ++i) {
        for(int j = 1; j < n; ++j) {
            if(g[i][j]) {
                addedge(i, j+n, node[i].num[id]);
            }
        }
    }
}


int main()
{
    //freopen("in", "r", stdin);
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);

        int sum = 0;
        scanf("%lf %lf", &node[0].x, &node[0].y);
        for(int i = 1; i < n; ++i) {
            scanf("%lf %lf %lf %lf", &node[i].x, &node[i].y, &node[i].b, &node[i].t);
            for(int j = 1; j <= m; ++j) {
                scanf("%d", &node[i].num[j]);
                sum += node[i].num[j];
            }
        }

        //sort(node+1, node+n);
        memset(g, 0, sizeof(g));
        for(int i = 1; i < n; ++i) {
            for(int j = 1; j < n; ++j) {
                double d = cal(node[i], node[j]);
                if(node[i].b+node[i].t+d <= node[j].b)
                    g[i][j] = 1;
            }
        }

        int ans = 0;
        int s = 0, t = 2*n+1;
        for(int i = 1; i <= m; ++i) {
             build(s, t, i);
             ans += max_flow(s, t);
        }
        ans = sum - ans;
        printf("%d\n", ans);
    }
}

ps：费用流的建边

 （s，n+i，人数，花费1）

 （s，i，人数，花费0）

 （i，i+n，人数，花费0）