BZOJ 1391 [Ceoi2008]order

1391: [Ceoi2008]order

Description

有N个工作，M种机器，每种机器你可以租或者买过来. 每个工作包括若干道工序，每道工序需要某种机器来完成,你可以通过购买或租用机器来完成。 现在给出这些参数，求最大利润

Input

第一行给出 N,M(1<=N<=1200,1<=M<=1200) 下面将有N块数据，每块数据第一行给出完成这个任务能赚到的钱(其在[1,5000])及有多少道工序 接下来若干行每行两个数，分别描述完成工序所需要的机器编号及租用它的费用(其在[1,20000]) 最后M行，每行给出购买机器的费用(其在[1,20000])

Output

最大利润

Sample Input

2 3
100 2
1 30
2 20
100 2
1 40
3 80
50
80
110

Sample Output

50

HINT

---

　　此题颇为有趣。一看便能知道是最大权闭合子图。但怎么区分租赁与购买呢？做了此题，再与BZOJ 1497 [NOI2006]最大获利比较，一下子我就明白了。

　　此题中，n个工作的获益先加在一起。源点S与n个工作连一条流量为获利的边，m台机器与汇点T连一条流量为购买费用的边，工作与机器之间连上相应的租赁费用。这样，跑一遍最大流（最小割），然后sum-maxflow即可。

　　为什么是对的？因为租赁可以理解为暂时的专属的，而购买就是永恒的普遍的。这在建图中体现的很明显。

　　而NOI那道题中，只不过没有租赁，所以工作与机器之间是inf。

　　很有意思啊！

 /**************************************************************
     Problem: 1391
     User: Doggu
     Language: C++
     Result: Accepted
     Time:4252 ms
     Memory:47844 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 template<class T>inline void readin(T &res) {
     static char ch;T flag=;
     while((ch=getchar())<''||ch>'')if(ch=='-')flag=-;
     res=ch-;while((ch=getchar())>=''&&ch<='')res=(res<<)+(res<<)+ch-;res*=flag;
 }

 const int N = ;
 const int M = ;
 struct Edge {int v,upre,cap,flow;}g[M];
 int head[N], ne=-;
 inline void adde(int u,int v,int cap) {
     g[++ne]=(Edge){v,head[u],cap,};head[u]=ne;
     g[++ne]=(Edge){u,head[v],,};head[v]=ne;
 }

 #include <queue>
 std::queue<int> q;
 int n, m, s, t, sum, d[N], cur[N];
 bool BFS() {
     while(!q.empty()) q.pop();
     memset(d,,sizeof(d));
     q.push(s);d[s]=;
     while(!q.empty()) {
         int u=q.front();q.pop();
         for( int i = head[u]; i != -; i = g[i].upre ) {
             int v=g[i].v;
             if(!d[v]&&g[i].cap>g[i].flow) q.push(v), d[v]=d[u]+;
         }
     }
     return d[t];
 }
 int DFS(int u,int a) {
     if(u==t||a==) return a;
     int flow=, f;
     for( int &i = cur[u]; i != -; i = g[i].upre ) {
         int v=g[i].v;
         if(d[v]==d[u]+&&(f=DFS(v,std::min(a,g[i].cap-g[i].flow)))>) {
             flow+=f;a-=f;
             g[i].flow+=f;g[i^].flow-=f;
             if(a==) break;
         }
     }
     if(flow==) d[u]=;
     return flow;
 }
 void maxflow() {
     int flow=;
     while(BFS()) {
         memcpy(cur,head,sizeof(head));
         flow+=DFS(s,0x3f3f3f3f);
     }
     printf("%d\n",sum-flow);
 }

 int main() {
     memset(head,-,sizeof(head));
     readin(n);readin(m);s=;t=n+m+;
     for( int i = , w, a, b, c; i <= n; i++ ) {
         readin(w);readin(b);
         adde(s,i,w);sum+=w;
         for( int j = ; j <= b; j++ ) {
             readin(a);readin(c);
             adde(i,n+a,c);
         }
     }
     for( int i = ,c; i <= m; i++ ) {
         readin(c);
         adde(n+i,t,c);
     }
     maxflow();
     return ;
 }
 

dinic最小割建图