bzoj2039

题意：作为一个富有经营头脑的富翁，小L决定从本国最优秀的经理中雇佣一些来经营自己的公司。这些经理相互之间合作有一个贡献指数,（我们用Ei,j表示i经理对j经理的了解程度），即当经理i和经理j同时被雇佣时，经理i会对经理j做出贡献，使得所赚得的利润增加Ei,j。当然，雇佣每一个经理都需要花费一定的金钱Ai，对于一些经理可能他做出的贡献不值得他的花费，那么作为一个聪明的人，小L当然不会雇佣他。 然而，那些没有被雇佣的人会被竞争对手所雇佣，这个时候那些人会对你雇佣的经理的工作造成影响，使得所赚得的利润减少Ei,j（注意：这里的Ei,j与上面的Ei,j 是同一个）。 作为一个效率优先的人，小L想雇佣一些人使得净利润最大。你可以帮助小L解决这个问题吗？

思路：

      把点集分成两个，很容易想到最小割模型。。

      但是最小割求出来的是最少去掉的。。

      所以我们想到了补集。。先所有都取然后去掉最少的。。

      建图如下：

          <S, i, sigma(E[i,j]) >

           <i, T, a[i]>

           <i, j, 2 * E[i][j]>

    最后跑一遍最大流。。

    答案即为sum(E[i][j]) - maxflow

 

code:

/*
 * Author:  Yzcstc
 * Created Time:  2014/10/25 19:54:45
 * File Name: bzoj2039.cpp
 */
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
#define M0(a) memset(a, 0, sizeof(a))
using namespace std;
typedef long long ll;
const int maxn = 1100;
const int Inf = 0x3fffffff;
const int maxm = 3100000;
struct oo{
      int y, next;
      ll f;
};
struct MaxFlow{
       int n, S, T, tot;
       int son[maxn], dist[maxn], gap[maxn];
       oo e[maxm];
       ll sap(int x,ll aug){
           if (x == T) return aug;
           int mind = n;
           ll sum = 0, f;
           for (int p = son[x]; p != -1; p = e[p].next){
                  int y = e[p].y;
                  if (dist[y] + 1 == dist[x] && e[p].f){
                       f = sap(y, min(e[p].f, aug - sum));
                       e[p].f -= f;
                       e[p^1].f += f;
                       sum += f;
                       if (sum == aug || dist[S] >= n) return sum;
                  }
                  if (e[p].f) mind = min(mind, dist[y]);
           }
           if (!sum){
               if (!(--gap[dist[x]])) dist[S] = n;
               ++gap[dist[x] = mind + 1];
           }
           return sum;
       }

       void add(int x, int y, ll f){
            e[tot].y = y; e[tot].f = f;
            e[tot].next = son[x]; son[x] = tot++;
            e[tot].y = x; e[tot].f = 0;
            e[tot].next = son[y]; son[y] = tot++;
       }

       void init(int S, int T, int n){
            memset(son, -1, sizeof(son));
            tot = 0;
            this->S = S, this->T = T, this->n = n;
       }
       ll maxflow(){
            M0(gap);
            M0(dist);
            gap[0] = n;
            ll ans = 0;
            while (dist[S] < n) ans += sap(S, Inf);
            return ans;
       }
} F;
int a[1200], n, m;
ll s[1200];
int e[1200][1200];
void solve(){
     for (int i = 1; i <= n; ++i)
           scanf("%d", &a[i]);
     M0(s);
     ll sum = 0;
     for (int i = 1; i <= n; ++i){
          for (int j = 1; j <= n; ++j)
               scanf("%d", &e[i][j]), s[i] += e[i][j], sum += e[i][j];
     }
     int S = 0,  T = n + 1;
     F.init(S, T, T + 1);
     for (int i = 1; i <= n; ++i)
          F.add(S, i, a[i]), F.add(i, T, s[i]);
     for (int i = 1; i <= n; ++i)
         for (int j = 1; j <= n; ++j) if (i != j)
               if (e[i][j] > 0) F.add(i, j, e[i][j] << 1);
     sum -= F.maxflow();
     cout << sum << endl;
}

int main(){
    while (scanf("%d", &n) != EOF){
          solve();
    }
    return 0;
}