CodeForces 311E Biologist

题目大意

给定n只狗，和m个人，每只狗变性需要花费$v_i$的代价，每个人会对一部分狗有一个期望性别（都为雄性或都为雌性），如果性别能够一一对上，就会获得$w_i$的利润，如果不能对上并且这个人比较重要，会减少$g$的获利。求能获得的最大利润。

解答

很容易能看出这是一个最小割模型，我们先把所有的获利相加得到$sum$，之后求最小消耗即可。
我们把每只狗变为雌性的代价做为边权连一条从$s$出来的边，同样把每只狗变为雄性的代价做为边权连一条到$t$的边。然后把每个希望狗是雄性的人连边到每个他需要的狗，边权为$\infty$，同样把每个希望狗是雌性的人从每个他需要的狗连一条边到他自己，边权也是$\infty$。
我们定义$P = \{所有最后是雄性的狗和所有要求狗是雄性的人\}$，同样定义$Q = \{所有最后是雌性的狗和所有要求狗是雌性的人\}$。
所以

$$C(P,Q)=\sum_{e=原来是雌性现在是雄性的狗 \to t}len(e)+\sum_{e=s\to原来是雌性现在是雄性的狗}len(e) + \sum_{e=人要求的性别没有实现}len(e)$$
$$当认为某个人需要的性别实现了但实际上没有实现时，C(P,Q)=\infty$$
所以求上述图的最小割即可。
附上一张图做参考

总结起来是一句话：割的时候，雄性的在一起，雌性的在一起，求两个集合之间的割

参考代码

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>

using namespace std;

const int oo = 2147483600;

class Edge
{
    public:
        int to;
        int next;
        int len;
};

Edge es[13107200];
int et = -1;
int head[20000];
int h[20000];
int fl[20000];
int st, th;
int n, m, g;
int sum = 0;
bool dog[20000];
int w[20000];

void addEdge(int u, int v, int l)
{
    et++;
    es[et].to = v;
    es[et].len = l;
    es[et].next = head[u];
    head[u] = et;
    et++;
    es[et].to = u;
    es[et].len = 0;
    es[et].next = head[v];
    head[v] = et;
}

bool bfs()
{
    memset(fl, -1, sizeof(fl));
    queue<int> ser;
    ser.push(st);
    fl[st] = 1;
    int x;
    bool flag = false;
    while (!ser.empty()) {
        x = ser.front();
        ser.pop();
        for (int i = head[x]; i != -1; i = es[i].next) {
            if (es[i].len && fl[es[i].to] == -1) {
                fl[es[i].to] = fl[x] + 1;
                if (es[i].to == th)
                    flag = true;
                ser.push(es[i].to);
            }
        }
    }
    return flag;
}

int dfs(int x, int flow)
{
    if (x == th)
        return flow;
    int cflow = flow;
    int ret;
    for (int &i = h[x]; i != -1; i = es[i].next)
        if (es[i].len && fl[es[i].to] == fl[x] + 1) {
            ret = dfs(es[i].to, min(es[i].len, flow));
            es[i].len -= ret;
            es[i^1].len += ret;
            flow -= ret;
            if (!flow)
                return cflow;
        }
    return cflow - flow;
}

int dinic()
{
    int ans = 0;
    while (bfs()) {
        for (int i = 0; i <= th; i++)
            h[i] = head[i];
        ans += dfs(st, oo);
    }
    return ans;
}

void readin()
{
    memset(head, -1, sizeof(head));
    cin >> n >> m >> g;
    st = 0;
    th = n+m+1;
    int w, k, v;
    bool se;
    for (int i = 1; i <= n; i++)
        cin >> dog[i];
    for (int i = 1; i <= n; i++) {
        cin >> w;
        if (dog[i])
            addEdge(st, i, w);
        else
            addEdge(i, th, w);
    }
    for (int i = 1; i <= m; i++) {
        cin >> se;
        cin >> w >> k;
        sum += w;
        for (int j = 0; j < k; j++) {
            cin >> v;
            if (se)
                addEdge(i+n, v, oo);
            else
                addEdge(v, i+n, oo);
        }
        cin >> v;
        if (v)
            w += g;
        if (se)
            addEdge(st, i+n, w);
        else
            addEdge(i+n, th, w);
    }
}

int main()
{
    ios::sync_with_stdio(false);
    readin();
    sum -= dinic();
    cout << sum;
    return 0;
}