牛客练习赛45F.Magic Slab（最大权闭合子图）

题目大意：

给你一个矩阵c，你可以选择任意一行一列，选择一行需要花费a[i]的费用，选择一列需要花费b[i]的费用，但是你可以得到C(i,j)的利润，此外，还有m个关联条件，比如你选择点(r1,c1)，(r2,c2)，你就可以得到ki的额外利润，问你最后能获得的最大利润是多少？

思路：

最大权闭合子图的常见模型。

仔细回想，最大权闭合子图是对于点而言的，而这里我们选择一行或者一列是有花费的，所以将行和列抽象成点，代表选择了这个行或者列的花费，因为是负数，所以这些点与汇点建边；

然后，每个矩阵中的点权值为正，与源点建边，同时不要忘了将这些点与行和列的节点建边，表示选择了这个点就必须选择这个行和这个列。

最后，对于每个关联条件，将其抽象为点，权值为正，所以与源点建边，然后这个点与有关的行和列

建边，表示使用这个关联条件必须选择这些行和列。

最后，答案就是所有正权值之和减去最小割。

这是没有关联的模型

如果有关联，也就是加了些点

#include <bits/stdc++.h>
using namespace std;

const int maxn=45*45+45*2+10005;
int a[maxn],b[maxn];//每行，每列的花费
int n,m;
const int INF=0x3f3f3f3f;
struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int cap,int flow):from(u),to(v),cap(cap),flow(flow){}
};
struct Dinic
{
    int n,m,s,t;
    vector<int>G[maxn];
    vector<Edge>edges;
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];
    void add_edges(int u,int v,int cap)
    {
        edges.push_back(Edge(u,v,cap,0));
        edges.push_back(Edge(v,u,0,0));
         m=edges.size();
        G[u].push_back(m-2);
        G[v].push_back(m-1);
    }
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<maxn;i++)G[i].clear();
        edges.clear();
    }
    //BFS构造层次图
    bool BFS()
    {
        memset(vis,0,sizeof(vis));
        memset(d,0,sizeof(d));
        queue<int>Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge &e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    //沿着层次图增广
    int DFS(int x,int a)
    {
        if(x==t||a==0)return a;
        int flow=0,f;
        for(int &i=cur[x];i<G[x].size();i++)
        {
            Edge &e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s=s;
        this->t=t;
        int flow=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
};

Dinic dinic;
signed main(){
    scanf("%d%d",&n,&m);
    dinic.init(n*n+2*n+m+10);
    int s=0,t=n*n+n*2+m+5;
    int ans=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            int temp;
            scanf("%d",&temp);
            int now=(i-1)*n+j;
            dinic.add_edges(s,now,temp);
            ans+=temp;
            dinic.add_edges(now,n*n+i,INF);
            dinic.add_edges(now,n*n+n+j,INF);
        }
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&b[i]);
    }
    for(int i=1;i<=n;i++){
        dinic.add_edges(n*n+i,t,a[i]);
    }
    for(int i=1;i<=n;i++){
        dinic.add_edges(n*n+n+i,t,b[i]);
    }

    for(int i=1;i<=m;i++){
        int r1,c1,r2,c2,k;
        scanf("%d%d%d%d%d",&r1,&c1,&r2,&c2,&k);
        int now=n*n+2*n+i;
        ans+=k;
        dinic.add_edges(s,now,k);
        dinic.add_edges(now,n*n+r1,INF);
        dinic.add_edges(now,n*n+r2,INF);
        dinic.add_edges(now,n*n+n+c1,INF);
        dinic.add_edges(now,n*n+n+c2,INF);
    }
    int maxflow=dinic.Maxflow(s,t);
   // printf("debug %d %d\n",ans,maxflow);
    printf("%d\n",ans-maxflow);
    return 0;

}