dijkstra 最小费用最大流

前言：众所周知:spfa他死了

滑稽

---

dijkstra同样为最短路算法，为什么不能跑费用流qwq

好像是因为有负权边的缘故

但是如果我们如果使用某种玄学的将边权都拉回到正数的话

就可以跑了dijkstra，开心qwq

---

如果我们每条边暴力加上一个很大的值的话，我们还需要记录所经过的边数，还要保证不溢出，十分的毒瘤

尻考虑给每个节点一个势（ps：不是什么物理学算法，就是为了给他起个名字）

然后将我们的最短路转移\(dis_v=dis_u+w\)改为\(dis_v=dis_u+w+h_u-h_v\)(\(h_i\)是势)，保证\(w+h_u-h_v>=0\)

然后我们观察蔡依林（雾他对最短路有什么影响

比如说我们现在有一条\(p_1-p_2-p_3.....p_n\)的这么一条路径

其路径长度则为\((w_1+w_2+w_3...+w_{n-1})+(h_1-h_2)+(h_2-h_3)+(h_3-h_4)+......(h_{n-1}-h_n)\)

然后发现这个玩意\(\to ~ (h_1-h_2)+(h_2-h_3)+(h_3-h_4)+......(h_{n-1}-h_n)=h_1-h_n\)。如此这样，我们在算出加势以后的（无论路线是什么样的）最短路后，在减去\(h_{begin}-h_{end}\)就可以了

---

接下来的问题就变成了，如何确定一个\(h_i\).

我们先考虑变形一下\(w+h_u-h_v>=0~~\to~~h_u+w>=h_v\)

\(wow\)，好像三角形不等式呀（在最短路中对于一条从\(u\)到\(v\)的有向边，总有\(dis_u+w>=dix_v\)）。

是不是可以考虑将上一次的\(dis\)当做\(h_i\)(每次\(h_i+=dis_i\))呢？

是可以的，为什么？

假设现在有一条\(u\to v\)的有向边

• 假设他是一条权值是正的（不加势）,那么肯定满足\(dis_u+w>=dis_v\)然就是最短路求错了。\(\therefore w+h_u-h_v>=0\)
• 如果是一条权值是负的话，我们的\(h_i\)是累加的\(dis_i\)的，所以必定存在某一次增广，是的\(v \to u\)的边变到了\(u \to v\)
  
  然后这次增广（就是将\(v \to u\)的边反向的增广），肯定满足\(dis_v+w==dis_u(w>=0)~~~\to~~dis_v=dis_u-w\)
  
  然后这时的\(dis_u,dis_v\)已经被我们累加到了\(h_u,h_v\)中，然后我们继续变形\(dis_u-w-dis_v==0 ~~~\to~~ h_u-h_v-w>=0\)
  
  然后\(-w\)是\(u\to v\)这条边的权值。所以这次并不会成为负数

\(\mathcal{So}\)

我们这样的话就能跑dijkstra了。开心\(qwq\)

而且更快，更稳定，也不容易猝死

---

↓及其丑陋的代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
const int maxn=101000;
using std::swap;
using std::min;
struct Edge
{
	int p;
	int w;
	int f;
	int nxt;
};
struct Data
{
	int p;
	int d;
	bool operator <(const Data &a)const
	{
		return d<a.d;
	}
};
int n,m,s,t;
int len;
Data base[maxn<<6];
Data top()
{
	return base[1];
}
void pop()
{
	swap(base[1],base[len--]);
	int pos=1;
	int nxt;
	while(true)
	{
		nxt=pos;
		if(base[pos<<1]<base[nxt]&&(pos<<1)<=len)
			nxt=pos<<1;
		if(base[pos<<1|1]<base[nxt]&&(pos<<1|1)<=len)
			nxt=pos<<1|1;
		if(pos==nxt)	break;
		swap(base[pos],base[nxt]);
		pos=nxt;
	}
}
void push(Data val)
{
	base[++len]=val;
	int pos=len;
	while((pos>>1)&&base[pos]<base[pos>>1])
	{
		swap(base[pos>>1],base[pos]);
		pos>>=1;
	}
	return ;
}
Edge line[maxn<<1];
int head[maxn],tail=-1;
void add(int a,int b,int c,int d)
{
	line[++tail].p=b;
	line[tail].w=c;
	line[tail].f=d;
	line[tail].nxt=head[a];
	head[a]=tail;
}
int h[maxn];
bool vis[maxn];
int dis[maxn];
int from[maxn];
int L[maxn];
int flow[maxn];
int Max_flow,Min_cost;
bool dijkstra(int begin,int end)
{
	len=0;
	for(int i=1;i<=n;i++)
	{
		dis[i]=0x7fffffff;
		flow[i]=0x7fffffff;
		from[i]=L[i]=vis[i]=0;
	}
	dis[begin]=0;
	Data pas;
	pas.p=begin;pas.d=0;
	push(pas);
	while(len)//手写堆怪我喽
	{
		pas=top();pop();
		while(vis[pas.p]&&len>=1)
		{
			pas=top();
			pop();
		}
		if(vis[pas.p]&&!len)	break;
		vis[pas.p]=true;
		dis[pas.p]=pas.d;
		for(int i=head[pas.p];i!=-1;i=line[i].nxt)
			if(line[i].f>0&&!vis[line[i].p]&&dis[line[i].p]>dis[pas.p]+line[i].w+h[pas.p]-h[line[i].p])//判断，带上势
			{
				dis[line[i].p]=dis[pas.p]+line[i].w+h[pas.p]-h[line[i].p];//跟spfa一样的套路，就是多了个势
				flow[line[i].p]=min(line[i].f,flow[pas.p]);
				from[line[i].p]=pas.p;
				L[line[i].p]=i;
				Data nxt;
				nxt.p=line[i].p;nxt.d=dis[line[i].p];
				push(nxt);
			}
	}
	return dis[end]!=0x7fffffff;
}
void MCMA(int begin,int end)
{
	while(dijkstra(begin,end))//差不多跟spfa一样的格式，就是加了个h数组
	{
		int max_flow=flow[end];
		Min_cost+=max_flow*(dis[end]-h[begin]+h[end]);
		Max_flow+=max_flow;
		for(int i=end;i!=begin;i=from[i])
		{
			line[L[i]].f-=max_flow;
			line[L[i]^1].f+=max_flow;
		}
		for(int i=1;i<=n;i++)
			h[i]+=dis[i];//累加，一定要累加，虽然不累加可能过几个点
	}
}
int main()
{
	scanf("%d%d%d%d",&n,&m,&s,&t);
	for(int i=1;i<=n;i++)	head[i]=-1;
	for(int i=1;i<=m;i++)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		add(a,b,d,c);add(b,a,-d,0);//建边
	}
	MCMA(s,t);//跑费用流
	printf("%d %d",Max_flow,Min_cost);//输出
	return 0;
}