【学习笔记】Primal-Dual 原始对偶算法
Johnson 全源最短路算法
Floyd 可以 \(O(n^3)\) 处理全源最短路，Bellman-Ford 单源最短路的复杂度是 \(O(nm)\) 的，Dijkstra 可以做到 \(O(m\log m)\) 但不能处理负边权，所以 Johnson 全源最短路算法通过处理使得可以用 \(n\) 次 Dijkstra 解决有负权图的全源最短路。
先建超级源点，向各点连边权为 \(0\) 的有向边，跑一次 Bellman-Ford，得到最短路 \(h\)，将 \(h_u\) 作为 \(u\) 节点的势能，将 \(d(u,v)\) 改为 \(d'(u,v)=d(u,v)+h_u-h_v\)。
这样在最短路过程中，\(p_1\to p_2\to \cdots\to p_{n-1}\to p_{n}\)，最短路值应该是：
注意到修改后的最短路较原来只和两端点势能有关，所以按照这个方法去做是可以找到最短路的。
同时根据 \(h_u+d(u,v)\ge h_v\)，则 \(d(u,v)+h_u-h_v\ge 0\)，也就是一个正权图。
这样复杂度是 \(O(nm\log m)\)。
Primal-Dual 原始对偶算法
其实和上面类似，这个算法解决了不含负环的费用流，复杂度不再是 EK 的上界 \(O(nmf)\)，其实就是改变了求最短路的算法。
依旧是从源点 \(S\) 开始跑 Bellman-Ford 记录势能 \(h_u\)，边权改为 \(d(u,v)+h_u-h_v\)。
问题在每次增广之后增加并减少了一些边。
这里的解决方案是，每次跑完 Dijkstra，把势能 \(h_u\) 改为 \(h_u+dis_u\)，这显然能代表最短路，证明和上面一样，关键是对边权是否全为正的讨论。
证明也是类似的，在上一次跑 Dijkstra 时，原有的边 \((u,v)\) 有 \(dis_u+(d(u,v)+h_u-h_v)\ge dis_v\)，于是 \(d(u,v)+(h_u+dis_u)-(h_v+dis_v)\ge 0\)，而新增加的边 \((v,u)\) 的反向边一定在最短路上，于是 \(dis_u+(d(u,v)+h_u-h_v)=dis_v\)，进而 \(d(v,u)+(h_v+dis_v)-(h_u+dis_u)=0\)，边权非负。
这样就可以在 \(O(nm+m\log mf)\) 的复杂度内解决问题，如果图有特殊性质，第一次的 Bellman-Ford 可以换成 BFS 之类的。
点击查看代码
int n,m;
int S,T;
struct edge{
int to,nxt,w,c;
}e[maxm<<1];
int head[maxn],cnt;
inline void add_edge(int u,int v,int w,int c){
e[++cnt].to=v,e[cnt].nxt=head[u],head[u]=cnt,e[cnt].w=w,e[cnt].c=c;
e[++cnt].to=u,e[cnt].nxt=head[v],head[v]=cnt,e[cnt].w=0,e[cnt].c=-c;
}
bool vis[maxn];
ll h[maxn];
queue<int> Q;
inline void SPFA(){
memset(vis,0,sizeof(vis));
memset(h,0x3f,sizeof(h));
vis[S]=true,h[S]=0;
Q.push(S);
while(!Q.empty()){
int u=Q.front();
Q.pop();
vis[u]=false;
for(int i=head[u],v,c;i;i=e[i].nxt){
v=e[i].to,c=e[i].c;
if(!e[i].w) continue;
if(h[u]+c<h[v]){
h[v]=h[u]+c;
if(!vis[v]){
vis[v]=true;
Q.push(v);
}
}
}
}
}
struct Data{
int u;
ll d;
Data()=default;
Data(int u_,ll d_):u(u_),d(d_){}
bool operator<(const Data &rhs)const{
return d>rhs.d;
}
};
priority_queue<Data> PQ;
ll dis[maxn];
int pre[maxn];
inline void Dijkstra(){
memset(vis,0,sizeof(vis));
memset(dis,0x3f,sizeof(dis));
dis[S]=0;
PQ.push(Data(S,0));
while(!PQ.empty()){
int u=PQ.top().u;
PQ.pop();
if(vis[u]) continue;
vis[u]=true;
for(int i=head[u],v;i;i=e[i].nxt){
v=e[i].to;
ll c=e[i].c+h[u]-h[v];
if(!e[i].w) continue;
if(dis[u]+c<dis[v]){
pre[v]=i;
dis[v]=dis[u]+c;
PQ.push(Data(v,dis[v]));
}
}
}
}
inline pll MCMF(){
pll res=make_pair(0,0);
SPFA();
while(1){
Dijkstra();
if(dis[T]==llinf) return res;
int mn=inf;
for(int u=T;u!=S;u=e[pre[u]^1].to) mn=min(mn,e[pre[u]].w);
res.fir+=mn;
for(int u=T;u!=S;u=e[pre[u]^1].to){
res.sec+=1ll*e[pre[u]].c*mn;
e[pre[u]].w-=mn,e[pre[u]^1].w+=mn;
}
for(int u=1;u<=n;++u) h[u]+=dis[u];
}
}
