网络流2太空飞行计划问题

题目大意：

某教授想通过一太空飞行计划进行一系列商业性实验而获取利润，有m个实验，n 个仪器。进行第 i 个实验 可获得利润 p 元，但需要 一些仪器，而且每个仪器需要花费一定的成本，问你如何选择实验，才能使得获得利润最大。

题目测试数据与数据范围：

2 3

10 1 2

25 2 3

5 6 7

1 2

1 2 3

17

数据范围不定。

题目分折：

首先可以确定这是最大权闭合图问题，可以转化为最小割问题，从而用最大流解决。建模方法为把每个实验看作二分图X集合中的顶点，把每个设备看作二分图的 Y 集合中的顶点。并增加 S ,T。

1，从 S 向每个 Xi 连接一条容量为该点收入的有向边。

2，从YI 向 T 连接一条容量为 该点支出的有向边。

3，如果一个实验 i 需要 设备 j ,连接一条从 Xi 向 Yj 容量为无穷大的有向边。

统计出所有实验的收入Total，求网络最大流Maxflow，最大收益就是 Total - Maxflow。对应的解就是最小割划分出 S 集合中的点，在找路径的时候，与流量有关即可。

小乐一下：

最大权闭合图是可以转化为网络流问题的，至于为什么能够这样做，可以去看相关资料。定义一个割划分出的S集合为一个解，那么割集的容量之和就是(未被选的A集合中的顶点的权值 + 被选的B集合中的顶点的权值)，记为Cut。A集合中所有顶点的权值之和记为Total，那么Total - Cut就是(被选的A集合中的顶点的权值 - 被选的B集合中的顶点的权值)，即为我们的目标函数，记为A。要想最大化目标函数A，就要尽可能使Cut小，Total是固定值，所以目标函数A取得最大值的时候，Cut最小，即为最小割。

该问题的一般模型为最大权闭合图，相关讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

我的代码，更好更简洁的由你来实现，（还是刘汝佳样式的模板），而且因为在题目中做一个实验的仪器数量没有给出，（当然可以考虑用 %c 的形式输入，但我简单化，就当每个实验只需要两个仪器输入了，而且在输出路径解的时候，格式有点问题，这些就都当做是一点小事吧，就留下这样一些错误吧，相信你能够看得出来。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int INF = 0x3fffffff;
const int maxn = 1005;

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

struct Dinic{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void Init(){
        for(int i = 0;i<maxn;i++) G[i].clear();
        edges.clear();
    }
    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);
         d[s] = 0;
         vis[s] = 1;
         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;
     }
     void Toans(int n){
         int i,u;
         for(u = 1;u<=n;u++){
            for(i = 0;i<G[u].size();i++){
                if(edges[G[u][i]].flow>0) {printf("%d ",u);break;}
            }
         }printf("\n");
         memset(vis,0,sizeof(vis));
         for(u = 1;u<=n;u++){
            for(i = 0;i<G[u].size();i++){
                if(edges[G[u][i]].flow>0){
                    if(!vis[edges[G[u][i]].to]){
                        printf("%d ",edges[G[u][i]].to-n);
                        vis[edges[G[u][i]].to] = 1;
                    }
                }
            }
         }
     }

};

int main(){
    Dinic Graph;
    int n,m;
    int i,j,p,a,b;
    int sum;
    while(scanf("%d%d",&n,&m)!=EOF){
        sum = 0;
       for(i = 1;i<=n;i++){
            scanf("%d%d%d",&p,&a,&b);
            sum += p;
            Graph.AddEdge(i,a+n,INF);
            Graph.AddEdge(i,b+n,INF);
            Graph.AddEdge(0,i,p);
       }
       for(i = 1;i<=m;i++){
            scanf("%d",&a);
            Graph.AddEdge(i+n,n+m+1,a);
       }
       printf("%d\n",sum-Graph.Maxflow(0,n+m+1));
       Graph.Toans(n);
    }
    return 0;
}

伟大的梦想成就伟大的人，从细节做好，从点点滴滴做好，从认真做好。