HDU 4307:Matrix

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4307

题目翻译：一个规模为1*N的矩阵A，其内元素值只能取0或1，提供一个N阶的方阵B，元素

值已只，提供一个1*N的矩阵C，其值也已知，AT 是A的转置矩阵，求（A*B-C）*（AT）的

最大值。

开始的时候没有看网上的题解，也不知道其中有什么规律，所以我就以N为4，对题目中的四个

矩阵做了运算（由于有转置矩阵的参与，我并不能很明确得找到关系，只能说运算来看看结果

怎么样），下图是我以N为4计算的结果。

我们知道矩阵A中每一个元素只能选0或1，所以我们可以再上图的最后一个式子中看出。对于A中的元素，

我们分为值为1的集合，和值为0的集合。如果我们选择第i个元素和第j个元素（在此我们随意选取i，j）,

只有i和j都是1的时候，如果i==j，我们获得bii的值，损失ci，如果i != j，则我们获得bij+bji+bii+bjj，损失

ci和cj的值。

因此我想到了最大闭合子图。最开始我的确也是这样写的。对于aii我把它看成一个点，若要获得aii

的价值，其前提是第i个点的值为1，aii这个点向源点S练一条权值为aii的边，且aii这个点向第i个点连

一条无穷大的边，同时我们把ci也看成一个点，建立与汇点T的联系，其权值为ci,由于第i个点选入S集

会造成ci的损失，所以从第i个点，向ci看成的点连接一条无穷大的边。也就是以权值作为点，向

S连边，然后该点向它所依赖的点连值为无穷大的边。

可悲的是，这样导致了边太多了，提交之后，直接TLE了。

然后只能寻求新的建图方法。从演算结果可以看出。

（1）如果第i个元素的值为1，我们可以获得sum(bij)的和，并损失ci,

（2）如果第i个元素的值为0，不能获取收益也不会扣去损失，等于说没什么影响。

（3）如果第i个元素的值为1，第j个元素的值为0，我们演算的时候，发现的是，如果第i个元素

和第j个元素都是1，则可以获得，bii,bij,bji,bjj这四个价值，由于j每选，bji和bjj我们并没有获得，

但是选了i的时候，我们选了bii,bij，这两项收益中，bij是再j也得是1得情况下，才能获得得，意思

就是我们多加了bij，所以当第i个元素是1，第j个元素是0，我们扣掉bij，即损失bij收益。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;

const int maxn = 2005000;
const int maxm = 1010;
const long long INF = 1e10;

int N,S,T,head[maxm],cnt,level[maxm],cur[maxm];
long long maxFlow;
struct Edge {
    int to;
    long long cap;
    int nex;
}edge[maxn];
void addEdge(int u,int v,long long cap) {
    edge[cnt].to = v;
    edge[cnt].cap = cap;
    edge[cnt].nex = head[u];
    head[u] = cnt++;

    edge[cnt].to = u;
    edge[cnt].cap = 0;
    edge[cnt].nex = head[v];
    head[v] = cnt++;
}
bool bfs() {
    memset(level,-1,sizeof(level));
    level[S] = 0;
    queue<int>qu;
    qu.push(S);
    while(!qu.empty()) {
        int u = qu.front();
        qu.pop();
        for(int i = head[u]; i != -1; i = edge[i].nex) {
            int v = edge[i].to;
            if(edge[i].cap>0 && level[v]==-1) {
                level[v] = level[u]+1;
                qu.push(v);
            }
        }
    }
    if(level[T] == -1)
        return false;
    else
        return true;
}
long long dfs(int u,long long flow) {
    if(u == T)
        return flow;
    long long sum = 0,tmp;
    for(int &i = cur[u]; i != -1; i = edge[i].nex) {
        int v = edge[i].to;
        if(edge[i].cap>0 && level[v]==level[u]+1) {
            tmp = dfs(v,min(flow-sum,edge[i].cap));
            edge[i].cap -= tmp;
            edge[i^1].cap += tmp;
            sum += tmp;
            if(sum == flow) return flow;
        }
    }
    if(sum == 0)
        level[u] = -1;
    return sum;
}
void dinic() {
    maxFlow = 0;
    while(bfs()) {
        for(int i = S; i <= T; i++) {
            cur[i] = head[i];
        }
        maxFlow += dfs(S,INF);
    }
}
int main() {
    int Case;
    long long sum,x;
    scanf("%d",&Case);
    while(Case--) {
        scanf("%d",&N);
        memset(head,-1,sizeof(head));
        cnt = 0;
        S = 0;
        T = N+1;
        long long all = 0;
        for(int i = 1; i <= N; i++) {
            sum = 0;
            for(int j = 1; j <= N; j++) {
                scanf("%lld",&x);
                addEdge(i,j,x);
                sum += x;
            }
            all += sum;
            addEdge(S,i,sum);
        }
        for(int i = 1; i <= N; i++) {
            scanf("%lld",&x);
            addEdge(i,T,x);
        }
        dinic();
        printf("%lld\n",all-maxFlow);
    }
    return 0;
}