BZOJ 3931: [CQOI2015]网络吞吐量【最短路+网络流

裸的最短路+乱搞+拆点+网络流

……忘了拆点会点数<<1，于是数组开小了又WA又T了一年【跪地不起我………………

反正点的流量限制就把它拆成入点和出点两个，中间加一条边就好了

找所有最短路直接for边就好……

…………拆点…………注意………………数组…………开大…………………………

裸题T了一年……果然我是要退役了QAQ

#include<bits/stdc++.h>
//#define Flaze_naive
#define MAXN 1515
#define MAXM 100057
#define INF 1000000000000000000ll
using namespace std;	int n,m;
int read_x[MAXM],read_y[MAXM],read_l[MAXM];
int S=0,T;
long long dis[MAXN];
int in_que[MAXN],que[MAXN],head,tail;
long long ans=0;

void addedge(int x,int y,long long liu);

struct t1{
	int to,lth;
	t1(){}
	t1(int to,int lth):to(to),lth(lth){}
};
vector<t1> e[MAXN];

void SPFA(int now){
	memset(dis,0x3f3f3f3f,sizeof dis);
	head=tail=0;
	que[tail++]=now;
	in_que[now]=1;
	dis[now]=0;
	while(head^tail){
		now=que[head++];
		if(head==MAXN)	head=0;
		in_que[now]=0;
		for(int tmp=0;tmp<e[now].size();++tmp){
			int aim=e[now][tmp].to;
			if(dis[aim]>dis[now]+e[now][tmp].lth){
				dis[aim]=dis[now]+e[now][tmp].lth;
				if(!in_que[aim])	que[tail++]=aim,in_que[aim]=1;
				if(tail==MAXN)	tail=0;
			}
		}
	}
}

int c[MAXN];
int iin[MAXN],ott[MAXN];
int cnt_node=0;
void build(int now){
	iin[1]=ott[1]=++cnt_node,iin[n]=ott[n]=++cnt_node;
	for(int i=2;i<n;++i)	
		iin[i]=++cnt_node,ott[i]=++cnt_node,
		addedge(iin[i],ott[i],c[i]);
	T=++cnt_node;
	addedge(S,iin[1],INF),addedge(ott[n],T,INF);	
	
	for(int i=1;i<=m;++i){
		if(dis[read_x[i]]==dis[read_y[i]]+read_l[i])
			addedge(ott[read_y[i]],iin[read_x[i]],INF);
		if(dis[read_x[i]]+read_l[i]==dis[read_y[i]])
			addedge(ott[read_x[i]],iin[read_y[i]],INF);
	}
}
//=======================================================================================
struct edge_for_dinic{
	int to,nxt;
	long long liu;
	int tag;
	edge_for_dinic(){}
	edge_for_dinic(int to,int nxt,long long liu):to(to),nxt(nxt),liu(liu){}
}edge[MAXM<<2];	int cnt_edge=1;
int fst[MAXN<<1],cur[MAXN<<1];

void addedge(int x,int y,long long liu){
	edge[++cnt_edge]=edge_for_dinic(y,fst[x],liu);
	fst[x]=cnt_edge;
	edge[++cnt_edge]=edge_for_dinic(x,fst[y],0);
	fst[y]=cnt_edge;
}

long long dfs(int now,long long low){
	if(now==T)	return low;
	long long rst=low;
	for(int &tmp=cur[now];tmp;tmp=edge[tmp].nxt){
		if(dis[now]+1!=dis[edge[tmp].to]||edge[tmp].liu<=0)	continue;
		int aim=edge[tmp].to;
		long long tt=dfs(aim,min(rst,edge[tmp].liu));
		if(tt){
			edge[tmp].liu-=tt;
			edge[tmp^1].liu+=tt;
			rst-=tt;
			if(!rst)	return low;
		}
	}
	if(low==rst)	dis[now]=-1;
	return low-rst;
}

bool bfs(int now){
	memset(dis,-1,sizeof dis);
	head=tail=0;
	que[tail++]=now;
	dis[now]=0;
	for(int i=S;i<=cnt_node;++i)	cur[i]=fst[i];
	cur[T]=fst[T];
	while(head^tail){
		now=que[head++];
		if(head==MAXN)	head=0;
		for(int tmp=fst[now];tmp;tmp=edge[tmp].nxt){
			int aim=edge[tmp].to;
			if(dis[aim]!=-1||edge[tmp].liu<=0)	continue;
			dis[aim]=dis[now]+1;
			que[tail++]=aim;
			if(tail==MAXN)	tail=0;
		}
	}
	return ~dis[T];
}

void dinic(){
	long long tt;
	while(bfs(S)){
		while(tt=dfs(S,INF))
			ans+=tt;
	}
}

//=======================================================================================


int main(){
#ifdef Flaze_naive
	freopen("1.in","r",stdin);
#endif 	
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;++i){
		scanf("%d%d%d",&read_x[i],&read_y[i],&read_l[i]);
		if(read_x[i]==read_y[i])	continue;
		e[read_x[i]].push_back(t1(read_y[i],read_l[i]));
		e[read_y[i]].push_back(t1(read_x[i],read_l[i]));
	}
	SPFA(1);
	for(int i=1;i<=n;++i)	scanf("%d",c+i);
	build(n);
	dinic();
	printf("%lld",ans);
	return 0;
}