HDU 5855-最大权闭合图（-最小割应用）

题意就是一个裸的最大权闭合图:

M个商店，N个工厂，每个商店获利的条件是建设了指定的k个工厂。求总获利不小于L，工厂建设的时间最大值最小是多少。

 工厂到汇点建一条边pay[i]，源点到商店建一条边pro[i]，商店到需要的工厂建一条边INF，商店的总收益-最小割就是答案

闭合图：一个有向图的子点集，使其中的点的出边都指回集合中的点，则称此为闭合图。

最大权闭合图：给每个点赋上点权，则权和最大的闭合图，为最大权闭合图。

算法（求最大权闭合子图）：

（1）新增源点和汇点s，t

（2）对于原图中的边u->v,增加一条u->v的容量为无穷大的边

（3）对于点u，如果w[u]>0,增加一条s->u的容量为w[u]的边；否则增加一条u->v的容量为-w[u]的边

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#include<stack>
using namespace std;
#include <fstream>
const int N=408;
const int inf=0x3f3f3f3f;
int min(int a,int b)
{
    return a<b?a:b;
}

int max_flow;//max_flow是最大流
int mp[N][N];// mp[i][j]是每条边的容量,flow[i][j]是每条边的流量
int pre[N];//res[]是每个点的剩余流量,pre[]是每个点的父亲
int level[N];//记录距离标号
int gap[N];//gap常数优化

//入口参数vs源点，vt汇点
int SAP(int vs,int vt)
{
    memset(pre,-1,sizeof(pre));
    memset(level,0,sizeof(level));
    memset(gap,0,sizeof(gap));
    gap[0]=vt;
    int v,u=pre[vs]=vs,maxflow=0,aug=inf;
    while(level[vs]<vt)
    {
        //寻找可行弧
        for(v=1; v<=vt; v++)
        {
            if(mp[u][v]>0&&level[u]==level[v]+1)
            {
                break;
            }
        }
        if(v<=vt)
        {
            pre[v]=u;
            u=v;
            if(v==vt)
            {
                aug=inf;
                //寻找当前找到的一条路径上的最大流
                for(int i=v; i!=vs; i=pre[i])
                {
                    if(aug>mp[pre[i]][i])aug=mp[pre[i]][i];
                }
                maxflow+=aug;
                //更新残留网络
                for(int i=v; i!=vs; i=pre[i])
                {
                    mp[pre[i]][i]-=aug;
                    mp[i][pre[i]]+=aug;
                }
                u=vs;//从源点开始继续搜
            }
        }
        else
        {
            //找不到可行弧
            int minlevel=vt;
            //寻找与当前点相连接的点中最小的距离标号
            for(v=1; v<=vt; v++)
            {
                if(mp[u][v]>0&&minlevel>level[v])
                {
                    minlevel=level[v];
                }
            }
            gap[level[u]]--;//(更新gap数组）当前标号的数目减1；
            if(gap[level[u]]==0)break;//出现断层
            level[u]=minlevel+1;
            gap[level[u]]++;
            u=pre[u];
        }
    }
    return maxflow;
}

int pay[205],ti[205];
int pro[205];
vector<int> pp[205];;
int L;
int n,m;
int  bin(int t)
{
    int st=n+m+1,ed=n+m+2;
    memset(mp,0,sizeof mp);
    int sum=0;
    for (int i=1; i<=m; i++)
    {
        mp[st][i]=pro[i];
        int flag=0;
        for (int j=0; j<pp[i].size(); j++)
        {
            int v=pp[i][j];
            if (ti[v]>t)
                flag=1;//pay[v];
        }
        if (!flag)
        {
            for (int j=0; j<pp[i].size(); j++)
                mp[i][pp[i][j]+m]=inf;
            sum+=pro[i];
        }
    }
    for (int i=1; i<=n; i++)
        if (ti[i]<=t) mp[m+i][ed]=pay[i];
    int ans=SAP(st,ed);
    return sum-ans;
}

int main()
{
    int k,tmp;
    int t;
    cin>>t;
    int cnt=1;
    while(t--)
        //while(~)
    {
        scanf("%d%d%d",&n,&m,&L);
        for (int i=1; i<=n; i++) scanf("%d%d",&pay[i],&ti[i]);
        for (int i=1; i<=m; i++)
        {
            pp[i].clear();
            scanf("%d",&pro[i]);
            scanf("%d",&k);
            for (int j=1; j<=k; j++)
            {
                scanf("%d",&tmp);
                pp[i].push_back(tmp);
            }
        }
        printf("Case #%d: ",cnt++);
        int l=1,r=1e9,ans=-1;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            int cnt=bin(mid);
            if (cnt>=L)
                r=mid-1,ans=mid;
            else
                l=mid+1;
        }
        if (ans==-1)
            printf("impossible\n");
        else printf("%d %d\n",ans,bin(ans));
    }
    return 0;
}