【最小割】BZOJ2039- [2009国家集训队]employ人员雇佣

【题目大意】

给定n个人，每个人有一个佣金，i和j如果同时被雇佣会产生2*E(i,j)的效益，i和j如果一个被雇佣一个不被雇佣会产生E(i,j)的亏损，求最大收益。

【思路】

如果没有亏损，其实非常类似这道题：★

注意在这类问题里的最小割指代的是损失最小化。对于这道题，我们把S看作雇佣，T看作不雇佣。

首先对于每一个cost[i],从点i出发向汇点连一条流量为cost[i]的边。

对于每一对点(i,j)，从S向点i和点j各连一条流量为E(i,j)的边，i和j之间连一条流量为2*E(i,j)的双向边。

ans最初等于矩阵里所有数的和。用ans减去最小割的时候，相当于割边没有被减去，而非割边被减去了。

如果割边是和S相连的，减去后，说明这个人雇佣了，付出了雇佣费，得到了一部分价值。

如果割边是和T相连的，减去后，说明没有雇佣，则没有付出雇佣费也没有得到价值。

那么对于一个被雇佣一个没有被雇佣呢？假设一个的割边与S连，一个的割边与Y连，那么必定会有中间的2*E（i，j）通过两者之间流走，所以他们之间的连边也必定成为割边。相当于得到了E[i,j]的价值，又丧失了2*E[i,j]的价值，总共丧失了E[i,j]的价值，符合题目意识。

dinic不知道为何写挂了，然后把程序里的函数一个一个拷贝到另一个空白界面重新编译了一下就过了，有毒quq没找到原来错在哪里。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #define S 0
 #define T n+1
 using namespace std;
 const int MAXN=+;
 const int INF=0x7fffffff;
 struct node
 {
     int to,pos,cap;
 };
 int m,n,ans=;
 vector<node> E[MAXN*];
 int dis[MAXN],e[MAXN][MAXN],sum[MAXN];

 void addedge(int u,int v,int w)
 {
     E[u].push_back((node){v,E[v].size(),w});
     E[v].push_back((node){u,E[u].size()-,});
 }

 void init()
 {
     scanf("%d",&n);
     int cost;
     for (int i=;i<=n;i++)
     {
         scanf("%d",&cost);
         addedge(i,T,cost);
     }
     int Eij;
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++)
         {
             scanf("%d",&e[i][j]);
             ans+=e[i][j];
             if (i!=j)
             {
                 sum[i]+=e[i][j];
                 addedge(i,j,*e[i][j]);
             }
         }
     for (int i=;i<=n;i++) addedge(S,i,sum[i]);
 } 

 bool bfs()
 {
     memset(dis,-,sizeof(dis));
     queue<int> que;
     while (!que.empty()) que.pop();
     que.push(S);
     dis[S]=;
     while (!que.empty())
     {
         int head=que.front();que.pop();
         if (head==T) return true;
         for (int i=;i<E[head].size();i++)
         {
             node tmp=E[head][i];
             if (dis[tmp.to]==- && tmp.cap)
             {
                 dis[tmp.to]=dis[head]+;
                 que.push(tmp.to);
             }
         }
     }
     return false;
 }

 int dfs(int s,int e,int f)
 {
     if (s==e) return f;
     int ret=;
     for (int i=;i<E[s].size();i++)
     {
         node &tmp=E[s][i];
         if (dis[tmp.to]==dis[s]+ && tmp.cap)
         {
             int delta=dfs(tmp.to,e,min(f,tmp.cap));
             if (delta>)
             {
                 tmp.cap-=delta;
                 E[tmp.to][tmp.pos].cap+=delta;
                 f-=delta;
                 ret+=delta;
                 if (f==) return ret;
             }
             else dis[tmp.to]=-;
         }
     }
     return ret;
 }

 void dinic()
 {
     while (bfs())
     {
         int f=dfs(S,T,INF);
         if (f) ans-=f;else break;
     }
     printf("%d\n",ans);
 }

 int main()
 {
     init();
     dinic();
     return ;
 }