【费用流】bzoj1834: [ZJOI2010]network 网络扩容

还是稍微记一下这个拆点模型吧

Description

给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。

求： 

1、在不扩容的情况下，1到N的最大流； 

2、将1到N的最大流增加K所需的最小扩容费用。

Input

第一行包含三个整数N,M,K，表示有向图的点数、边数以及所需要增加的流量。 

接下来的M行每行包含四个整数u,v,C,W，表示一条从u到v，容量为C，扩容费用为W的边。

N<=1000，M<=5000，K<=10

Output

输出文件一行包含两个整数，分别表示问题1和问题2的答案。

---

题目分析

这里只考虑第二问：第一眼看上去像是二分或者最小费用可行流。然而在残量网络里将源点拆为$S$和$S‘$再连$(S,S',K,0)$的边来限制图中新增的费用是一种更好的模型。

以后再遇到个数限制时候，要及时想到 拆点 的这一类处理方式。

 #include<bits/stdc++.h>
 //const int maxn = 1035;
 const int maxm = ;
 const int maxNode = ;
 const int INF = 2e9;

 struct Edge
 {
     int u,v,f,c,cst;
     Edge(int a=, int b=, int c=, int d=, int e=):u(a),v(b),f(c),c(d),cst(e) {}
 }edges[maxm],sv[maxm];
 int n,m,K,ans1,ans2,S,T,SS;
 int edgeTot,head[maxNode],nxt[maxm],bck[maxNode],cst[maxNode],flw[maxNode];
 bool inq[maxNode];

 int read()
 {
     char ch = getchar();
     int num = , fl = ;
     for (; !isdigit(ch); ch=getchar())
         if (ch=='-') fl = -;
     for (; isdigit(ch); ch=getchar())
         num = (num<<)+(num<<)+ch-;
     return num*fl;
 }
 void addedge(int u, int v, int c, int cst)
 {
     edges[edgeTot] = Edge(u, v, , c,  cst), nxt[edgeTot] = head[u], head[u] = edgeTot, ++edgeTot;
     edges[edgeTot] = Edge(v, u, , , -cst), nxt[edgeTot] = head[v], head[v] = edgeTot, ++edgeTot;
 }
 std::pair<int, int> maxFlow()
 {
     int flow = , cost = ;
     for (;;)
     {
         std::queue<int> q;
         memset(bck, , sizeof bck);
         memset(flw, , sizeof flw);
         memset(cst, 0x3f3f3f3f, sizeof cst);
         q.push(S), cst[S] = , flw[S] = INF;
         for (int tmp; q.size(); )
         {
             tmp = q.front(), q.pop(), inq[tmp] = ;
             for (int i=head[tmp]; i!=-; i=nxt[i])
             {
                 int v = edges[i].v;
                 if (cst[v] > cst[tmp]+edges[i].cst&&edges[i].f < edges[i].c){
                     cst[v] = cst[tmp]+edges[i].cst, bck[v] = i;
                     flw[v] = std::min(flw[tmp], edges[i].c-edges[i].f);
                     if (!inq[v]) q.push(v), inq[v] = ;
                 }
             }
         }
         if (!flw[T]) break;
         for (int i=T; i!=S; i=edges[bck[i]].u)
             edges[bck[i]].f += flw[T], edges[bck[i]^].f -= flw[T];
         flow += flw[T], cost += flw[T]*cst[T];
     }
     return std::make_pair(flow, cost);
 }
 int main()
 {
     memset(head, -, sizeof head);
     n = read(), m = read(), K = read();
     for (int i=; i<=m; i++)
     {
         int u = read(), v = read(), c = read(), cst = read();
         sv[i] = Edge(u, v, , c, cst), addedge(u, v, c, );
     }
     SS = , S = , T = n;
     ans1 = maxFlow().first;
     std::swap(S, SS);
     addedge(S, SS, K, );
     for (int i=; i<=m; i++)
         addedge(sv[i].u, sv[i].v, INF, sv[i].cst);
     ans2 = maxFlow().second;
     printf("%d %d\n",ans1,ans2);
     return ;
 }

END