HDU 4971 A simple brute force problem

HDU 4971 A simple brute force problem

网络流，最大权闭合子图

传送门：HustOJ

题意

给你一些问题，一些项目。解决每个问题有花费，完成每个项目有奖励。问题之间有关系，解决有的问题必须先解决其他某些问题，还有的问题之间是相互依赖的，即必须一起解决。问你最大收益是多少。

思路

%%%

最大权闭合子图问题。具体有论文：网络流模型的应用。

说一下建图方式：超级源，向每个项目连边，权值是收益；项目向问题连边，问题之间耦合关系连边，权值正无穷；问题连边到汇，权值是解决问题的花费。

最后答案就是权值和减最大流。

代码

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <set>
#include <map>

#define _ ios_base::sync_with_stdio(0),cin.tie(0)
#define M(a,b) memset(a,b,sizeof(a))
using namespace std;

const int oo=0x3f3f3f3f;
typedef unsigned long long LL;
const LL loo=4223372036854775807ll;
typedef long double LB;
const LL mod=1e9+7;

const int MAXN=4007;
struct Dinic
{
    struct Edge
    {
        int from, to, cap, flow;
        Edge() {}
        Edge(int u, int v, int c, int f) { from=u;to=v;cap=c;flow=f; }
    };

    vector<Edge> edges;
    vector<int> G[MAXN];
    bool vis[MAXN];
    int d[MAXN];
    int cur[MAXN];
    void init(int n)
    {
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }
    void AddEdge(int from, int to, int cap)
    {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        int t_m=edges.size();
        G[from].push_back(t_m-2);
        G[to].push_back(t_m-1);
    }
    bool BFS(int s, int t)
    {
        M(vis, 0);
        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, int s, int t)
    {
        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), s, t))>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)
    {
        int flow=0;
        while(BFS(s, t))
        {
            M(cur, 0);
            flow+=DFS(s, oo, s, t);
        }
        return flow;
    }
}dinic;

int main()
{
    int T, v, p;scanf("%d", &T);
    long long sum;
    int n, m;
    for(int t=0;t<T;t++)
    {
        dinic.init(MAXN);
        sum=0;
        scanf("%d %d", &n, &m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d", &v);
            dinic.AddEdge(0, i, v);
            sum+=v;
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d", &v);
            dinic.AddEdge(i+n, n+m+1, v);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d", &p);
            for(int j=1;j<=p;j++)
            {
                scanf("%d", &v);
                dinic.AddEdge(i, v+n+1, 100000);
            }
        }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=m;j++)
            {
                scanf("%d", &v);
                if(v)
                    dinic.AddEdge(i+n, j+n, 100000);
            }
        printf("Case #%d: %lld\n", t+1, sum-dinic.Maxflow(0, n+m+1));
    }
    return 0;
}