【NOIP模拟】Snow

                                              Snow

题目描述

有一天，TT 要去 ABC 家。ABC 的大门外有 n 个站台，用 1 到 n 的正整数编号，TT 需要对每个站台访问恰好一定次数以后才能到 ABC 家。站台之间有 m 个单向的传送门，通过传送门到达另一个站台不需要花费任何代价。而如果不通过传送门，TT 就需要乘坐公共汽车，并花费 1 单位的钱。值得庆幸的是，任意两个站台之间都有公共汽车直达。

现在给定每个站台必须访问的次数，对于站台 i ，TT 必须恰好访问 Fi 次（不能超过）。

我们用 u，v，w 三个参数描述一个传送门，表示从站台 u 到站台 v 有一个最多可以使用 w 次的传送门（不一定要使用 w 次）。对于任意一对传送门 (u1,v1) 和 (u2,v2)，如果有 u1<u2，则有v1≤v2；如果有 v1<v2 ，则有 u1≤u2；且 u1=u2 和 v1=v2 不同时成立。

TT 可以从任意的站台开始，从任意的站台结束。出发去开始的站台需要花费 1 单位的钱。现在请帮助 TT 求出打开大门最少需要花费多少单位的钱。

输入格式

第一行包含两个正整数 n，m，意义见题目描述。
第二行包含 n 个正整数，第 i 个数表示 Fi。
接下来有 m 行，每行有三个正整数 u，v，w，表示从 u 到 v 有一个可以使用 w 次的传送门。

输出格式

输出仅一行包含一个整数表示答案。

样例数据 1

输入

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

输出

17

备注

【数据范围】
有 20% 的数据满足 n≤10,m≤50；
有 50% 的数据满足 n≤1000，m≤10000；
100% 的数据满足 1≤n≤10000，1≤m≤100000；
对于所有的 u，v，满足 1≤u,v≤n；u≠v；对于所有的 w,Fi，满足 1≤w,Fi≤50000。
以上的每类数据中都存在 50% 的数据满足对于所有的 w,Fi，有 w=Fi=1。

 

解析：

       太懒了直接贴上题解。。。

       首先解释一下为什么当 wi=fi=1  时可以转化成最小路径覆盖问题，回忆一下最小路径覆盖问题求的是最少的路径数使得这些路径经过了所有的点，回到题目我们可以发现如果按照给出的边跑最小路径条数就是最小花费，因为当你走完一条路径要换成另一条路径就说明现在要走一条不是传送门的路，那么就要花费1的代价，所以最终换了若 N 条路径则花费为 N-1 ，但是题目中有说”出发去开始的站台需要花费 1 单位的钱“，那么 N-1+1 就正好是 N 了，所以这样做是正确的。

       然后考虑一般情况，算法5的构图方式就巧妙地说明了点 u 只能作为起点或终点 fi 次，最终就算出了有多少个点作为了起点，等价于多少条路径。

       但是最小路径覆盖问题要求必须是有向无环图，有向保证了，但是无环呢？这里我请教大佬获得了一种证法，但可能不够严谨：

       对于一条边e(u,v)，有两种情况 u<v 或 u>v （数据保证u!=v）。

       先讨论u<v的情况

       那么对于任意e0(v,v0)

       因为u<v

       所以v<=v0

       而v0!=v

       所以v0>v>u

       u>v的情况一样的证发

       故永远不可能成环。

 

代码（算法5）：

#include <bits/stdc++.h>
using namespace std;

const int Maxn=10010;
const int Maxm=100010;
const int inf=1000000000;
int n,m,size=1,s,t,sum,ans;
int first[Maxn<<2],depth[Maxn<<2],num[Maxn],tmp[Maxn<<2];
struct shu{int to,next,len;};
shu edge[Maxm<<4];

inline int get_int()
{
	int x=0,f=1;
	char c;
	for(c=getchar();(!isdigit(c))&&(c!='-');c=getchar());
	if(x=='-') {f=-1;c=getchar();}
	for(;isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+c-'0';
	return x*f;
}

inline void build(int x,int y,int z)
{
	edge[++size].next=first[x];
	first[x]=size;
	edge[size].to=y;
	edge[size].len=z;
}

inline bool bfs()
{
	memset(depth,0,sizeof(depth));
	queue<int>q;
	q.push(s);
	depth[s]=1;
	while(!q.empty())
	{
	  int point = q.front();
	  q.pop();
	  for(int u=first[point];u;u=edge[u].next)
	  {
	  	int to=edge[u].to;
	  	if(!edge[u].len || depth[to]) continue;
	  	depth[to] = depth[point] + 1;
	  	q.push(to);
	  }
	}
	return depth[t]>0 ? 1 : 0;
}

inline int dinic(int point,int flow)
{
	if(point==t) return flow;
	int sum=0;
	for(int &u=tmp[point];u&&sum<flow;u=edge[u].next)
	{
	  int to=edge[u].to;
	  if(depth[to] != depth[point] + 1 || !edge[u].len) continue;
	  int minn=dinic(to,min(flow-sum,edge[u].len));
	  if(!(flow-sum)) {depth[to]=0;break;}
	  edge[u].len-=minn,edge[u^1].len+=minn;
	  sum+=minn;
	}
	return sum;
}

inline void solve()
{
	while(bfs())
	{
	  memcpy(tmp,first,sizeof(tmp));
	  ans += dinic(s,inf);
	}
}

int main()
{
	n=get_int(),m=get_int();
	t=2*n+10;
	for(int i=1;i<=n;i++) num[i]=get_int(),sum+=num[i];
	for(int i=1;i<=n;i++)
	{
	  build(s,i,num[i]),build(i,s,0);
	  build(i+n,t,num[i]),build(t,i+n,0);
	}
	for(int i=1;i<=m;i++)
	{
	  int x=get_int(),y=get_int(),z=get_int();
	  build(x,y+n,z),build(y+n,x,0);
	}

	solve();
	cout<<sum-ans<<"\n";

	return 0;
}