uva7264(最小割)

第一次体验了一番过金牌题拿铜。。

看到题目其实先想到的是最大权封闭子图，以此出发我们把图一步步完善。。

PS：写博客的时候发现自己的建图完全反过来了，然而这并不影响答案。。因此S和T反过来了，T就表示最大权封闭子图了。。

首先最大权封闭子图只考虑到了依赖关系和代价，而这题是必须要选一个，没有收益，为了选那个必选的，我们可以设那个必选点的收益为正无穷，即该点向T连容量为无穷的边。。

然后考虑其他限制，首先是可以去除依赖关系的，考虑最大权封闭子图的构建意义，将依赖容量为无穷的目的正是为了保持依赖联系，因此，只要把容量重新设为去除依赖关系的代价，割去这条边，就与去除依赖关系并付出代价的意义想一致了。。

然后还有一个限制就是可以直接通过高价获取这个物品而无视依赖关系这个条件，我们可以考虑拆点，把i拆成i和i'，i连着原来的入边，i'连着原来的出边，i与i'连边，容量为这个无视关系需要的代价，割去该边，就把i需要的依赖关系割去了而i'仍保留在封闭子图中，符合题目的意义。。

因此总结起来。。建图方式如下：

设必取点为v，每个点拆成i和i'

1.S与i连边，容量为购买i的代价

2.v与T连边，容量无穷

3.i与i'连边，容量为强制购买i的代价

4.对限制条件<u,v>和去除该条件的代价k，u和v连边，容量为k

然后跑最小割。。

 

 

 

/**
 *　　　　　　  　　┏┓　　 　┏┓
 * 　　　　　  　　┏┛┗━━━━━━━┛┗━━━┓
 * 　　　　　  　　┃　　　　　　　┃ 　
 * 　　　　　  　　┃　　　━　　 　┃
 * 　　　　　  　　┃　＞　　　＜　┃
 * 　　　　　  　　┃　　　　　　　┃
 * 　　　　　  　　┃...　⌒　... 　┃
 * 　　　　　　  　┃              ┃
 * 　　　　　　  　┗━┓          ┏━┛
 * 　　　　　　　　　┃          ┃　Code is far away from bug with the animal protecting　　　　　　　　　　
 * 　　　　　　　　　┃          ┃   神兽保佑,代码无bug
 * 　　　　　　　　　┃          ┃　　　　　　　　　　　
 * 　　　　　　　　　┃          ┃  　　　　　　
 * 　　　　　　　　　┃          ┃
 * 　　　　　　　　　┃          ┃　　　　　　　　　　　
 * 　　　　　　　　　┃          ┗━━━┓
 * 　　　　　　　　　┃              ┣┓
 * 　　　　　　　　　┃              ┏┛
 * 　　　　　　　　　┗┓┓┏━━━━━━━━┳┓┏┛
 * 　　　　　　　　　　┃┫┫       ┃┫┫
 * 　　　　　　　　　　┗┻┛       ┗┻┛
 */
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
#include<cmath>
#include<map>
#include<stack>
#include<set>
#include<bitset>
#define inc(i,l,r) for(int i=l;i<=r;i++)
#define dec(i,l,r) for(int i=l;i>=r;i--)
#define link(x) for(edge *j=h[x];j;j=j->next)
#define mem(a) memset(a,0,sizeof(a))
#define ll long long
#define eps 1e-8
#define succ(x) (1LL<<(x))
#define lowbit(x) (x&(-x))
#define sqr(x) ((x)*(x))
#define mid ((x+y)/2) 
#define NM 1005
#define nm 30005
#define N 1000005
#define M(x,y) x=max(x,y)
const double pi=acos(-1);
const ll inf=20101009;
using namespace std;
ll read(){
    ll x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch))x=x*10+ch-'0',ch=getchar();
    return f*x;
}



struct edge{int t,v;edge*next,*rev;}e[nm],*h[NM],*o=e,*p[NM],*tmp[NM];
void _add(int x,int y,int v){o->t=y;o->v=v;o->next=h[x];h[x]=o++;}
void add(int x,int y,int v){_add(x,y,v);_add(y,x,0);h[x]->rev=h[y];h[y]->rev=h[x];}
int n,m,cnt[NM],d[NM],tot,_x,_y,_t;
 
 
 
int maxflow(){
    int flow=0;edge*j;tot=n+1;
    mem(cnt);mem(d);mem(tmp);mem(p);
    inc(i,0,n)tmp[i]=h[i];
    cnt[0]=tot;
    for(int x=0,s=inf;d[x]<tot;){
	for(j=tmp[x];j;j=j->next)if(j->v&&d[x]==d[j->t]+1)break;
	if(j){
	    s=min(s,j->v);p[j->t]=tmp[x]=j;
	    if((x=j->t)==n){
		for(;p[x];x=p[x]->rev->t)p[x]->v-=s,p[x]->rev->v+=s;
		flow+=s;s=inf;
	    }
	}else{
	    if(!-cnt[d[x]])break;d[x]=tot;
	    link(x)if(j->v&&d[x]>d[j->t]+1)tmp[x]=j,d[x]=d[j->t]+1;
	    cnt[d[x]]++;
	    if(p[x])x=p[x]->rev->t;
	}
    }
    return flow;
}


int main(){
    //freopen("data.in","r",stdin);
    int _=read();while(_--){
	mem(e);mem(h);o=e;
	n=read();m=read();
	add(read()+n,2*n+1,inf);
	while(m--){
	    _x=read();_y=read();_t=read();
	    add(_x+n,_y,_t);
	}
	inc(i,1,n)add(0,i,read());
	inc(i,1,n)add(i,i+n,read());
	n=2*n+1;
	printf("%d\n",maxflow());
    }
    return 0;
}