[LOJ.AC] 最大权闭合图 #6001. 「网络流 24 题」太空飞行计划

求最大权闭合图，这是一个非常抽象的问题，具体可以参考下面这篇论文，有严谨的证明：
《最小割模型在信息学竞赛中的应用》

在许多实际应用中，给出的有向图常常是一个有向无环图（DAG），闭合图的性质恰好反
映了事件间的必要条件的关系：一个事件的发生，它所需要的所有前提也都要发生。一个常
见的例子就是制定大学的选课计划，其中一些课程需要以另一些课程为基础，这就是给出了
有向无环图。若给所有课程打分，最大权闭合图对应了获益最大或效率最高的选课计划，解
决了这个问题，就可以容易地选出一个最合理的选课计划。

在另外一些实际应用中，给出的是一个一般有向图，即有可能出现圈。常见的例子就是
工程分期，一个工程可能含有很多项目，项目之间也有依赖关系。有些项目是需要同期一起
开发，互相依赖的（即出现圈）。这样，也可以利用最大权闭合图，将最先应该完成的项目选
出来作为工程的第一期。

建模方法

对于这个问题，把每个实验看作权值为正顶点，每个设备看作权值为负顶点。

我们已知了一个带权顶点(事件)集合 $V$ 并且知道依赖关系，需要求点权和最大的集合，下面给出做法：

增加源 $s$ 和汇 $t$。

1、从 $s$ 向每个点权为正的点连接一条容量为该点权值的有向边。
2、从点权为负的点 向 $t$ 连接一条容量为该点权值绝对值的有向边。
3、对所有 点 连接所有 依赖的点 容量为无穷大的有向边。

统计出所有实验的收入之和Total，求网络最大流Maxflow，最大收益就是Total-Maxflow。

跑完最大流后的，假设最小的割集为 $[S, T]$ ，那么 $S-\{s\}$ 就是点权和最大的集合，即最大权闭合图。

例题

code

#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
//#include <unordered_map>
//#include <unordered_set>
#include <vector>
using namespace std;

#define mp make_pair
#define pb push_back
#define se second
#define fi first
#define rep(i, n) for(int i = 0; i < n; ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;

const int MOD = (int)1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1.0);
const db EPS = 1e-10;

const int MAXV = 405;
const int MAXE = 15005;

int V, E;

struct edge{
    int to, cap, cost, nxt;
    edge() {}
    edge(const int _to, const int _cap, const int _nxt) {
        to = _to;
        cap = _cap;
        nxt = _nxt;
    }
}dat[MAXE<<1];

int head[MAXV], tail;

void add_edge(int from, int to, int cap) {
    dat[tail] = edge(to, cap, head[from]);
    head[from] = tail++;
    dat[tail] = edge(from, 0, head[to]);
    head[to] = tail++;
}

int level[MAXV], iter[MAXV];

queue<int> que;
void bfs(int s) {    
    memset(level, 0xff, sizeof(int) * (V + 1));
    level[s] = 1;
    que.push(s);
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int v = head[u]; ~v; v = dat[v].nxt) {
            edge &e = dat[v];
            if(level[e.to] < 0 && e.cap > 0) {
                level[e.to] = level[u] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int u, int t, int f) {
    if(u == t) return f;
    for(int &v = iter[u]; ~v; v = dat[v].nxt) {
        edge &e = dat[v];
        if(e.cap > 0 && level[e.to] > level[u]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                dat[v^1].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t) {
    int res = 0, f;
    while(true) {
        bfs(s);
        if(level[t] < 0) return res;
        memcpy(iter, head, sizeof(int) * (V + 1));
        while((f = dfs(s, t, INF)) > 0) res += f;
    }
    return res;
}

int m, n, vis[MAXV];
void get(int u) {
    vis[u] = true;
    for(int v = head[u]; ~v; v = dat[v].nxt) {
        edge &e = dat[v];
        if(e.cap > 0 && !vis[e.to]) {
            get(e.to);
        }
    }
}

int main()
{
    scanf("%d%d", &m, &n);
    int s = 0, t = V = m + n + 1, sum = 0;
    memset(head, 0xff, sizeof(int) * (V + 1));
    tail = 0;
    for(int i = 1; i <= m; ++i) {
        int val, x; char ch;
        scanf("%d%c", &val, &ch);
        sum += val;
        add_edge(s, i, val);
        while(ch != '\n' && ch != '\r' ) {
            scanf("%d%c", &x, &ch);
            add_edge(i, x + m, INF);
        }
    }
    for(int i = 1; i <= n; ++i) {
        int val;
        scanf("%d", &val);
        add_edge(i + m, t, val);
    }
    int res = max_flow(s, t);
    get(s);
    bool flag = false;
    for(int i = 1; i <= m; ++i) {
        if(vis[i]) {
            printf(flag?" %d":"%d", i);
            flag = true;
        }
    }if(flag) puts("");
    flag = false;
    for(int i = m + 1; i <= m + n; ++i) {
        if(vis[i]) {
            printf(flag?" %d":"%d", i - m);
            flag = true;
        }
    }if(flag) puts("");
    printf("%d\n", sum - res);
    return 0;
}

W 教授正在为国家航天中心计划一系列的太空飞行。每次太空飞行可进行一系列商业性实验而获取利润。现已确定了一个可供选择的实验集合$E = \{ E_1, E_2, \cdots, E_m \}$和进行这些实验需要使用的全部仪器的集合 $I = \{ I_1, I_2, \cdots, I_n \}$。实验 $E_j$​​ 需要用到的仪器是 $I$ 的子集 $R_j \subseteq I$。

配置仪器 $I_k$ 的费用为 $c_k$​​ 美元。实验 $E_j$​ 的赞助商已同意为该实验结果支付 $p_j$​​ 美元。W 教授的任务是找出一个有效算法，确定在一次太空飞行中要进行哪些实验并因此而配置哪些仪器才能使太空飞行的净收益最大。这里净收益是指进行实验所获得的全部收入与配置仪器的全部费用的差额。

对于给定的实验和仪器配置情况，编程找出净收益最大的试验计划。

输入格式

第 1 行有 2 个正整数 m 和 n 。m 是实验数，n 是仪器数。接下来的 m 行，每行是一个实验的有关数据。第一个数赞助商同意支付该实验的费用；接着是该实验需要用到的若干仪器的编号。最后一行的 n 个数是配置每个仪器的费用。

输出格式

第 1 行是实验编号，第 2 行是仪器编号，最后一行是净收益。

样例
样例输入
2 3
10 1 2
25 2 3
5 6 7
样例输出
1 2
1 2 3
17
数据范围与提示
$1 \leq n, m \leq 50$