P1361 小M的作物 最小割理解

如果没有组合效益的存在 我们直接每个点两部分的最大值即可

换成网络流模型来看 即把S点看作是A田 把T点看作是B田 每种作物看作一个点 分别连边(S,i,A[i]) (i,T,B[i])

最后图中所有边权和减去最大流即为答案.这个很好理解,因为最小割=最大流,一种作物只能选择A,B里的一个

所以对于每个点必要删去一条边,删去的边相当于我们不要的选项 剩下的和S,T相连的边相当于我们的选择 此时删去的肯定是最小的边.

接下来我们要处理组合效应的问题.

每个组合效应有三种选择:A/B/无

这样对于每个组合只建一个点很难满足要求 则我们把每个组合拆成A,B两个点  A点和S建边(S,A,C1[i])  B点和T建边(B,T,C2[i]) 表示选择A,B能得到的贡献.

再对于组合里的每个数都连边(A,K[i],INF) (K[i],B,INF) 这样图中除边权为INF的边的边权减去跑出来的最大流即为答案.

为什么这样跑出来即是我们选择要删去的选项？

因为最小割不可能会割INF的边

每个组合效应的A点 他旗下的每个点要都选A他才能产生贡献,如果有一个选了B则会产生增广路径,那么就必须要割掉(S,A,C1[i])

每个组合效应的B点 他旗下的每个点要都选B他才能产生贡献,如果有一个选了A则同样会产生增广路径,必须要割掉(B,T,C2[i])

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N=;
const int M=;
const int inf=0x3f3f3f3f;
int head[N],edge[M],to[M],next[M],cnt=;
void add(int u,int v,int w)
{
    to[++cnt]=v;next[cnt]=head[u];edge[cnt]=w;head[u]=cnt;
    to[++cnt]=u;next[cnt]=head[v];edge[cnt]=;head[v]=cnt;
}
int dep[N],used[N],pre[N],tot,s[N],ans,m,n,sum;
queue <int > q;
bool bfs()
{
    while(!q.empty()) q.pop();
    q.push();
    memset(dep,,sizeof(dep));
    dep[]=;
    while(!q.empty()&&q.front()!=n+)
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=next[i])
        {
            int v=to[i],w=edge[i];
            if(!dep[v]&&w)
            {
                dep[v]=dep[u]+;
                q.push(v);
            }
        }
    }
    return !q.empty();
}
int main()
{
    scanf("%d",&n);
    int w,v,k,c1,c2;
    for(int i=;i<=n;i++)
    {
        scanf("%d",&w);
        sum+=w;
        add(,i,w);
    }
    for(int i=;i<=n;i++)
    {
        scanf("%d",&w);
        sum+=w;
        add(i,n+,w);
    }
    scanf("%d",&m);
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&k,&c1,&c2);
        add(,i+n+,c1);sum+=c1;
        add(i+n+m+,n+,c2);sum+=c2;
        for(int j=;j<=k;j++)
        {
            scanf("%d",&v);
            add(i+n+,v,inf);
            add(v,i+n+m+,inf);
        }
    }
    while(bfs())
    {
        memset(used,,sizeof(used));
        s[++tot]=;
        while(tot)
        {
            int u=s[tot];
            if(u==n+)
            {
                int mi=inf,id;
                for(int i=tot;i>;i--)
                    if(mi>=edge[pre[s[i]]])
                    {
                        mi=edge[pre[s[i]]];
                        id=i;
                    }
                ans+=mi;
                for(int i=tot;i>;i--)
                {
                    edge[pre[s[i]]]-=mi;
                    edge[pre[s[i]]^]+=mi;
                }
                tot=id-;
                used[n+]=;
            }
            else
            {
                for(int i=head[u];i;i=next[i])
                {
                    int v=to[i],w=edge[i];
                    if(!used[v]&&dep[v]==dep[u]+&&w)
                    {
                        used[v]=;
                        s[++tot]=v;
                        pre[v]=i;
                        break;
                    }
                }
                if(u==s[tot]) tot--;
            }
        }
    }
    printf("%d\n",sum-ans);
    return ;
}