P1361 小M的作物 最小割构图 二者取一问题

题目链接

小M在MC里开辟了两块巨大的耕地A和B（你可以认为容量是无穷），现在，小P有n中作物的种子，每种作物的种子有1个（就是可以种一棵作物）（用1…n编号）。

现在，第i种作物种植在A中种植可以获得ai的收益，在B中种植可以获得bi的收益，而且，现在还有这么一种神奇的现象，就是某些作物共同种在一块耕地中可以获得额外的收益，小M找到了规则中共有m种作物组合，第i个组合中的作物共同种在A中可以获得c1i的额外收益，共同总在B中可以获得c2i的额外收益。

小M很快的算出了种植的最大收益，但是他想要考考你，你能回答他这个问题么？

输入格式
第一行包括一个整数n

第二行包括n个整数，表示ai第三行包括n个整数，表示bi第四行包括一个整数m接下来m行，

对于接下来的第i行：第一个整数ki，表示第i个作物组合中共有ki种作物，

接下来两个整数c1i，c2i，接下来ki个整数，表示该组合中的作物编号。

输出格式
只有一行，包括一个整数，表示最大收益

输入输出样例
sample input

3
4 2 1
2 3 2
1
2 3 2 1 2

sample output
11
官方题解:https://www.luogu.org/problemnew/solution/P1361
一开始不太明白样例给出的 最后一行2 3 2 1 2 是怎么回事，按照题意，1号和1号可以共种，但是题目中明确说每一类种子只有一个，这就不符合题意了，看了题解好像这是成对出现的 ，应该这样去看样例，第i行要说明i与某号种子可以共种。这样就差不多了。
对于最小割的建模问题[HDU6598]这里还有一个(https://blog.csdn.net/c___c18/article/details/97398383)

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstring>
#include<set>
#include<queue>
#include<stack>
#include<map>
typedef long long ll;
using namespace std;
const ll INF=0x3f3f3f3f3f3f3f3f;
struct node{
    ll from,to,cap,flow;
};
vector<int>G[20000];
vector<node>edge;
void add(int from ,int to,ll cap){
    edge.push_back((node){from,to,cap,0});
    edge.push_back((node){to,from,0,0});
    int m=edge.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}
int s,t;
bool vis[20000];
int d[20000],cur[20000];

bool bfs(){
    memset(vis,0,sizeof vis);
    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++){
            node& e=edge[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];
}

ll dfs(int x,ll a){
    if(x==t|| a==0) return a;
    ll flow=0,f;
    for(int & i=cur[x]; i< G[x].size(); i++){
        node & e = edge[G[x][i]];
        if(d[x]+1==d[e.to] && (f=(dfs(e.to,min(a,e.cap-e.flow))))>0){
            e.flow+= f;
            edge[G[x][i]^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}

ll dinic(){
    ll flow=0;
    memset(d,0,sizeof d);
    while(bfs()){
        memset(cur,0,sizeof cur);
        flow+=dfs(s,INF);
    }
    return flow;
}
ll a[20000],b[20000];
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif // ONLINE_JUDGE
    int n,m;
    scanf("%d",&n);
    s=n+1;t=n+2;
    ll sum=0;
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        sum+=a[i];
        add(s,i,a[i]);
    }
    for(int i=1;i<=n;i++){
        scanf("%lld",&b[i]);
        sum+=b[i];
        add(i,t,b[i]);
    }
   scanf("%d",&m);
   for(int i=1;i<=m;i++){int num;ll c1,c2;
        scanf("%d%lld%lld",&num,&c1,&c2);
        int v1=n+10+i,v2=n+100+i;
        add(s,v1,c1);
        add(v2,t,c2);
        sum+=c1+c2;
        for(int j=1;j<=num;j++){int u;
            scanf("%d",&u);
            add(v1,u,INF);
            add(u,v2,INF);
        }
   }

        printf("%lld\n",sum-dinic());
        return 0;
}

类似的题目还有一个简单点的，方格取数