Kejin Game

 UVALive - 7264 

給出一張技能圖，有的技能需要先置條件才能學習，而通過氪金可以取消某一些先置條件或者直接學習某一項技能，假設學習某項技能或者氪金都需要你付出一些代價，問代價最少為多少？

首先我們來審視某一個技能C，假設他存在先置技能A,B，那麼我們使用一些原則來構建一張圖：

假設一個技能直接習得的代價是D則在從該技能的入點向出點連線一條邊；

假如一個技能是另一個的前置技能，那麼就從前置技能的出點向待學習技能的入點連線一條邊；

源點向所有技能的入點連線一條學習該技能所需的代價。

按照上面的法則，我們就可以構建出下面這樣一張圖

假使在ss，想要學習的技能的出點之間形成一個割，那麼意味著這個技能就算被習得了。

以C為例，假設C想要脫離A這個前置的控制，那麼就需要在Va，Dva，EDac之間任意選取一條邊劃去，同理取消B的限制也是一樣的，再割裂Vc就算完全從正常學習的流程中學得了C技能了，當然也可以通過直接割裂Dvc這條邊來達到形成割的目的

那麼由此，我們可以感受到，這種建模的方式確實是合理的。（原諒我不能給出完備的證明）

AC程式碼：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
#include<map>
using namespace std;
const int maxn=5005;
const int maxm=2e5+5;
const int inf=0x3f3f3f3f;
struct Edge{
	int to,nxt,cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
	tol=2;
	memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w,int rw=0){
	edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
	edge[tol].nxt=head[u];head[u]=tol++;
	edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
	edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
bool bfs(int s,int t,int n){
	int front=0,tail=0;
	memset(dep,-1,sizeof(dep[0])*(n+1));
	dep[s]=0;
	Q[tail++]=s;
	while(front<tail){
		int u=Q[front++];
		for(int i=head[u];i!=-1;i=edge[i].nxt){
			int v=edge[i].to;
			if(edge[i].cap>edge[i].flow&&dep[v]==-1){
				dep[v]=dep[u]+1;
				if(v==t) return true;
				Q[tail++]=v;
			}
		}
	}
	return false;
}
int dinic(int s,int t,int n){
	int maxflow=0;
	while(bfs(s,t,n)){
		for(int i=0;i<n;i++) cur[i]=head[i];
		int u=s,tail=0;
		while(cur[s]!=-1){
			if(u==t){
				int tp=inf;
				for(int i=tail-1;i>=0;i--)
				{
					tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
				}
				maxflow+=tp;
				for(int i=tail-1;i>=0;i--){
					edge[sta[i]].flow+=tp;
					edge[sta[i]^1].flow-=tp;
					if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
				}
				u=edge[sta[tail]^1].to;
			}
			else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
				sta[tail++]=cur[u];
				u=edge[cur[u]].to;
			}
			else{
				while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
				cur[u] = edge [cur[u]].nxt;
			}
		}
	}
	return maxflow;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,m,k;
		scanf("%d%d%d",&n,&m,&k);
		int ss=0,tt=2*n+1;
		init();
		for(int i=1;i<=m;i++)
		{
			int u,v,k;
			scanf("%d%d%d",&u,&v,&k);
			addedge(u+n,v,k);
		}
		for(int i=1;i<=n;i++)
		{
			int p;
			scanf("%d",&p);
			addedge(ss,i,p);
		}
		for(int i=1;i<=n;i++)
		{
			int p;
			scanf("%d",&p);
			addedge(i,i+n,p);
		}
		addedge(k+n,tt,inf);
		printf("%d\n",dinic(ss,tt,2*n+1));
	}
}
/*
2
5 5 5
1 2 5
1 3 5
2 4 8
4 5 10
3 5 15
3 5 7 9 11
100 100 100 200 200
*/