hdu 3917 Road constructions 最大权闭合图-优快云博客

本文链接：https://blog.youkuaiyun.com/luyuncheng/article/details/7932059

题目大意：

*n个点，k条边，m个修路公司，每个公司有一个正的税收收益，现在k条边每条由某个公司负责相应的有相应的费用，

*　规则是这样的：如果选择了某个公司，该公司负责的所有的路都要选，还有如果1->2的路由公司A负责，2->3的路由公司B负责，那么如果选了公司A就必须选公司B，求最大的收益

思路：把每个工程队的税收为正权，连源点。每个工程队的施工总和为 C[i]，连汇点，值为C[i]; 有联系的工程队之间连有向边，边权为inf。答案为所以税收总和-最大流

胡伯涛最小割应用，最大权闭合图。一模一样的，具体看论文

#include<iostream> 
#include<stdio.h> 
#include<memory.h> 
#include<cmath> 
using namespace std;   
#define MAXN 5005 
#define MAXE 100002 
#define INF 1e9-1      
int ne,nv,tmp,s,t,index;  
struct Edge{ 
    int next,pair; 
    int v,cap,fLow; 
}edge[MAXE];
    
int c[5005];
struct team
{
	int a,b,c;	
}team[4003];
int net[MAXN]; 
int ISAP() 
{ 
	int numb[MAXN],dist[MAXN],curedge[MAXN],pre[MAXN]; 
 
    int cur_fLow,max_fLow,u,tmp,neck,i; 
    memset(dist,0,sizeof(dist)); 
    memset(numb,0,sizeof(numb)); 
    memset(pre,-1,sizeof(pre)); 
    for(i = 1 ; i <= nv ; ++i) 
        curedge[i] = net[i]; 
    numb[nv] = nv; 
    max_fLow = 0; 
    u = s; 
    while(dist[s] < nv) 
    { 
        if(u == t) 
        { 
            cur_fLow = INF; 
            for(i = s; i != t;i = edge[curedge[i]].v)  
            {   
                if(cur_fLow > edge[curedge[i]].cap) 
                { 
                    neck = i; 
                    cur_fLow = edge[curedge[i]].cap; 
                } 
            } 
            for(i = s; i != t; i = edge[curedge[i]].v) 
            { 
                tmp = curedge[i]; 
                edge[tmp].cap -= cur_fLow; 
                edge[tmp].fLow += cur_fLow; 
                tmp = edge[tmp].pair; 
                edge[tmp].cap += cur_fLow; 
                edge[tmp].fLow -= cur_fLow; 
            } 
            max_fLow += cur_fLow; 
            u = neck; 
        } 
        /* if .... eLse ... */
        for(i = curedge[u]; i != -1; i = edge[i].next) 
            if(edge[i].cap > 0 && dist[u] == dist[edge[i].v]+1) 
                break; 
        if(i != -1) 
        { 
            curedge[u] = i; 
            pre[edge[i].v] = u; 
            u = edge[i].v; 
        }else{ 
            if(0 == --numb[dist[u]]) break; 
            curedge[u] = net[u]; 
            for(tmp = nv,i = net[u]; i != -1; i = edge[i].next) 
                if(edge[i].cap > 0) 
                    tmp = tmp<dist[edge[i].v]?tmp:dist[edge[i].v]; 
            dist[u] = tmp + 1; 
            ++numb[dist[u]]; 
            if(u != s) u = pre[u]; 
        } 
    }      
    return max_fLow; 
}
void addedge(int u,int v,int f)
{
	edge[index].next = net[u]; 
    edge[index].v = v; 
    edge[index].cap = f; 
    edge[index].fLow = 0; 
    edge[index].pair = index+1; 
    net[u] = index++; 
    edge[index].next = net[v]; 
    edge[index].v = u; 
    edge[index].cap = 0; 
    edge[index].fLow = 0; 
    edge[index].pair = index-1; 
    net[v] = index++;
	
} 
int main() { 
    int i,j,np,nc,m,n; 
    int a,b,d,k,vaL; 
    while(scanf("%d%d",&n,&m),n+m) 
    { 
		int conte=0;
		nv=m+2;// 有m+2个点 
		index=0;//index从0开始扫 
        s = 0; 
        t = m+1; 
		memset(c,0,sizeof(c)); 
        memset(net,-1,sizeof(net));
		int temp;
		int sumtxt=0;
		int sum=0;
		for(i=1;i<=m;i++) 
        {
			scanf("%d",&temp);
			addedge(0,i,temp);
			sumtxt+=temp;
		}
		scanf("%d",&k);		
		for(i=1;i<=k;i++) 
        { 
            scanf("%d%d%d%d",&team[i].a,&team[i].b,&team[i].c,&temp); 
            c[team[i].c]+=temp;//记录费用 
         } 
         /*判断两个工程队是不是有关系*/
         for(i=1;i<=k;i++)
		 { 
             for(j = 1; j <= k;j++) 
			 { 
                 if(i!=j && team[i].c!=team[j].c && team[i].b==team[j].a) 
                 	{addedge(team[i].c,team[j].c,INF);} 
            } 
		}
		for(i=1;i<=m;i++)
		{
			addedge(i,t,c[i]);
			
		}
		int ans=sumtxt-ISAP();
		printf("%d\n",ans); 
    } 
    return 0; 
}

此处是sap加loop的套用模板的做法

给出n,个工程，m个公司，给出每个公司施工需要上交的税务 tax，给出k 个工程之间的关系，以及政府补助c，项目可处理对象 d！并且要求如果选取i 公司担任这个工程，那么i 公司负责的项目也相应必须有它负责！！同时，与其” 相连 “的公司j 也必须担任” 相连“的任务！！！问政府可以获得的最高利润？！

解法：

最大流最小割！

最大利润=获得最大利益-支付最少补助！！！获得最大利益=雇佣公司税务之和！支付最少补助=雇佣的公司的补助！最大利润=所有公司税务之和-（未雇佣公司税务之和+支付最少补助）！！很显然，后面的为割，而为使利润最大割应最小！！ans=sum-max_flow!!

构图：

我们首先让起始点 s 与各个 i 公司建边边权为 tax[i]，然后再让各个公司i 与 sink 建边，权值为担任的任务补助之和；并且如果公司 i 和 j 存在“相连”关系的也建立边的关系，权值为inf;

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<memory.h>
using namespace std;
const int M=10002;
const int INF=(1e9)-1;
int t,n,m,tot;
int gap[M],dis[M],pre[M],head[M],cur[M],s[M];
int NE,NV,sink,a[M],b[M],c[M],d[M];
struct Node
{
    int c,pos,next;
} E[M*4];
#define FF(i,NV) for(int i=0;i<NV;i++)
int sap(int s,int t)
{
    memset(dis,0,sizeof(int)*(NV+1));
    memset(gap,0,sizeof(int)*(NV+1));
    FF(i,NV) cur[i] = head[i];
    int u = pre[s] = s,maxflow = 0,aug =INF;
    gap[0] = NV;
    while(dis[s] < NV)
    {
loop:
        for(int &i = cur[u]; i != -1; i = E[i].next)
        {
            int v = E[i].pos;
            if(E[i].c && dis[u] == dis[v] + 1)
            {
                aug=min(aug,E[i].c);
                pre[v] = u;
                u = v;
                if(v == t)
                {
                    maxflow += aug;
                    for(u = pre[u]; v != s; v = u,u = pre[u])
                    {
                        E[cur[u]].c -= aug;
                        E[cur[u]^1].c += aug;
                    }
                    aug =INF;
                }
                goto loop;
            }
        }
        if( (--gap[dis[u]]) == 0)   break;
        int mindis = NV;
        for(int i = head[u]; i != -1 ; i = E[i].next)
        {
            int v = E[i].pos;
            if(E[i].c && mindis > dis[v])
            {
                cur[u] = i;
                mindis = dis[v];
            }
        }
        gap[ dis[u] = mindis+1 ] ++;
        u = pre[u];
    }
    return maxflow;
}
void addEdge(int u,int v,int c )
{
    E[NE].c = c;
    E[NE].pos = v;
    E[NE].next = head[u];
    head[u] = NE++;
    E[NE].c = 0;
    E[NE].pos = u;
    E[NE].next = head[v];
    head[v] = NE++;
}
int main()
{
    int n, m,sum, source, sink, vn,k;
    while(scanf("%d %d", &n, &m),(n||m))
    {
        NE=0,tot=0;
        sum = 0;
        source = 0;
        sink=m+1;
        NV=sink+1;
        memset(head, -1, sizeof(head));
        memset(s,0,sizeof(s));
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&vn);
            addEdge(source,i,vn);
            sum+=vn;
        }
        scanf("%d",&k);
        for(int i=1;i<=k;i++)
        {
            scanf("%d%d%d%d",&a[i],&b[i],&d[i],&c[i]);
            s[d[i]]+=c[i];
        }
        for(int i=1;i<=k;i++)
        {
            for(int j=1;j<=k;j++)
            {
                if(i!=j&&b[i]==a[j]&&d[i]!=d[j])
                {
                    addEdge(d[i],d[j],INF);

                }
            }
        }
        for(int i=1;i<=m;i++)
        {
            addEdge(i,sink,s[i]);
        }
        printf("%d\n",sum-sap(source,sink));
    }
    return 0;
}