P1361 小M的作物 最大流最小割原理

原题链接：https://www.luogu.com.cn/problem/P1361

题意

有n个作物，种在A田可以获得ai权值，种在B田可以获得bi权值，接下来有一些作物组合放在AB田可以获得附加值c1,c2，问如何种植可以取得最大值

分析

一个植物可以种在A也可以种在B，非常明显的二选一操作，最后将作物分在两个集合中并且集合之间没有交集。可以想到最小割的原理，割去一些边使得两个集合没有交集，并且要取得最大值，那么割的边就要尽量小。

然后就是建图，先建两个超级原点，源点向作物连边，作物向汇点连边，这样基本的模型就完成了。然后是组合的情况，我们每次都建两个虚点代表A的附加值和B的附加值，从源点向虚点Ai连边边权是C1，Ai向组内的作物连边边权是INF，Bi同理，最后跑一遍最大流就可以了。

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <bitset>
#include <map>
#include <set>
#include <stack>
#include <queue>
//#include <unordered_map>
using namespace std;
#define fi first
#define se second
#define re register
typedef long long ll;
typedef pair<ll, ll> PII;
typedef unsigned long long ull;
const int N = 1e5 + 10, M = 1e6 + 5, INF = 0x3f3f3f3f;
const int MOD = 1e9+7;
int st, ed, n;
ll ans;
struct Maxflow {
    int h[N], cnt, deep[N], cur[N];
    ll maxflow;
    struct Edge {
        int to, next;
        ll cap;
    } e[M<<1];

    void init() {
        memset(h, -1, sizeof h);
        cnt = maxflow = 0;
    }
    void add(int u, int v, int cap) {
        e[cnt].to = v;
        e[cnt].cap = cap;
        e[cnt].next = h[u];
        h[u] = cnt++;

        e[cnt].to = u;
        e[cnt].cap = 0;
        e[cnt].next = h[v];
        h[v] = cnt++;
    }

    bool bfs() {
        for (int i = 0; i <= 3010; i++) deep[i] = -1, cur[i] = h[i];
        queue<int> q; q.push(st); deep[st] = 0;
        while (q.size()) {
            int u = q.front();
            q.pop();
            for (int i = h[u]; ~i; i = e[i].next) {
                int v = e[i].to;
                if (e[i].cap && deep[v] == -1) {
                    deep[v] = deep[u] + 1;
                    q.push(v);
                }
            }
        }
        if (deep[ed] >= 0) return true;
        else return false;
    }

    ll dfs(int u, ll mx) {
        ll a;
        if (u == ed) return mx;
        for (int i = cur[u]; ~i; i = e[i].next) {
            cur[u] = i;//优化
            int v = e[i].to;
            if (e[i].cap && deep[v] == deep[u] + 1 && (a = dfs(v, min(e[i].cap, mx)))) {
                e[i].cap -= a;
                e[i ^ 1].cap += a;
                return a;
            }
        }
        return 0;
    }

    void dinic() {
        ll res;
        while (bfs()) {
            while (1) {
                res = dfs(st, INF);
                if (!res) break;
                maxflow += res;
            }
        }
    }
}mf;

void solve() {
    cin >> n; mf.init();
    vector<int> a(n+1), b(n+1);
    st = n+1, ed = n+2;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    for (int i = 1; i <= n; i++) {
        mf.add(st, i, a[i]);
        mf.add(i, ed, b[i]);
        ans += a[i] + b[i];
    }
    int q; cin >> q;
    for (int i = 1; i <= q; i++) {
        int num, c1, c2; cin >> num >> c1 >> c2;
        ans += c1 + c2;
        mf.add(st, n+i+2, c1);
        mf.add(n+i+q+2, ed, c2);
        for (int j = 1; j <= num; j++) {
            int x; cin >> x;
            mf.add(x, n+i+q+2, INF);
            mf.add(n+i+2, x, INF);
        }
    }
    mf.dinic();
    cout << ans - mf.maxflow << endl;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
    return 0;
}