最小割网络流

最新推荐文章于 2024-07-15 07:43:36 发布

原创最新推荐文章于 2024-07-15 07:43:36 发布 · 167 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#网络流

网络流专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个基于Dinic算法实现的最大流问题解决方案，并通过具体代码展示了如何构造网络图、添加边及其容量限制，最终计算从源点到汇点的最大流量。适用于解决涉及网络流的计算机科学问题。

题目：https://nanti.jisuanke.com/t/26172

真的很明显的模板题阿阿。可惜我自己平时的问题。居然不知道这个问题用什么模板。透李奶奶阿。

#include <stdio.h>  
#include <string.h>  
#include <iostream>  
#include <algorithm>
#include <math.h>
#include <map> 
#include <queue>
#include <vector> 
#define PI 3.1415926
#define INF 1e18
#define inf 1e9
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define IOS ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std ;
typedef long long ll;
typedef unsigned long long ull;
const int _max = 50000;
struct Dinic                  
{                   
       struct node                
       {                 
             int c,u,v,next;                
       }edge[_max];                
       int ne,head[_max];                
       int cur[_max], ps[_max], dep[_max];              
       void initial()                
       {                
             ne=2;                
             memset(head,0,sizeof(head));                 
       }                
       void addedge(int u, int v,int c)                
       {                 
             edge[ne].u=u,edge[ne].v=v,edge[ne].c=c,edge[ne].next=head[u];                
             head[u]=ne++;                
             edge[ne].u=v,edge[ne].v=u,edge[ne].c=0,edge[ne].next=head[v];                
             head[v]=ne++;                
       }                
       ll MaxFlow(int s,int t)                
       {                                     
             ll tr, res = 0;                
             int i,j,k,f,r,top;                
             while(1)                
             {                
                    memset(dep, -1, sizeof(dep));                
                    for(f=dep[ps[0]=s]=0,r=1;f!= r;)                
                       for(i=ps[f++],j=head[i];j;j=edge[j].next)                
                         if(edge[j].c&&dep[k=edge[j].v]==-1)                
                         {                
                               dep[k]=dep[i]+1;                
                               ps[r++]=k;                
                               if(k == t){  f=r; break;  }                
                         }                
                    if(dep[t]==-1) break;                
                    memcpy(cur,head,sizeof(cur));                
                    i=s,top=0;                
                    while(1)                
                    {                
                         if(i==t)                
                         {                
                               for(tr=inf,k=0;k<top;k++)                
                                  if(edge[ps[k]].c<tr)                
                                     tr=edge[ps[f=k]].c;                
                               for(k=0;k<top;k++)                
                               {                
                                     edge[ps[k]].c-=tr;                
                                     edge[ps[k]^1].c+=tr;                
                               }                
                               i=edge[ps[top=f]].u;                
                               res+= tr;                
                         }                
                         for(j=cur[i];cur[i];j=cur[i]=edge[cur[i]].next)                 
                             if(edge[j].c && dep[i]+1==dep[edge[j].v]) break;                 
                         if(cur[i])  ps[top++]=cur[i],i=edge[cur[i]].v;                 
                         else                
                         {                
                                 if(!top) break;                
                                 dep[i]=-1;                
                                 i=edge[ps[--top]].u;                
                         }                
                   }                
             }                
             return res;                
      }           
}T;  
int main(){
    IOS;
    int t;
    cin>>t;
    int n,m,n1,n2,val;
    while(t--){
        cin>>n>>m;
        int src=n+m+1,des=n+m+2;
        ll sum = 0;
        T.initial();
        for(int i = 1 ; i <= n ; i++){//chanping
            cin>>val;
            sum += val;
            T.addedge(src,i,val);
        }
        for(int i = 1 ; i <= m ; i++){//kuang
            cin>>val;
            T.addedge(i+n,des,val);
        }
        for(int i = 1 ; i <= n ; i++){
            cin>>n1>>n2;
            for(int j = 1 ; j <= n1 ; j++){
                cin>>val;
                T.addedge(i,val+n,inf);
            }
            for(int j = 1 ; j <= n2 ; j++){
                cin>>val;
                T.addedge(i,val,inf);
            }
        } 
        cout<<sum-T.MaxFlow(src,des)<<endl;
    }
    return 0;
}