【学习笔记】Primal-Dual 原始对偶算法

合集 - 学习笔记(42)

1.【学习笔记】Kruskal 重构树2022-11-252.【学习笔记】网络流2022-12-153.【学习笔记】高级数据结构2022-12-214.【学习笔记】线性基2022-12-275.【学习笔记】Link Cut Tree2022-12-286.【学习笔记】字符串后缀算法2022-12-307.【学习笔记】字符串回文算法2023-01-128.【学习笔记】组合数学2023-01-279.【学习笔记】多项式 1：基础操作2023-01-3010.【学习笔记】多项式 2：集合幂级数2023-02-0311.【学习笔记】多项式 3：多项式运算2023-02-1112.【学习笔记】Prufer 序列2023-02-1513.【学习笔记】多项式 4：生成函数2023-02-1514.【学习笔记】DP 套 DP2023-02-1915.【学习笔记】图的连通性2023-02-2216.【学习笔记】差分约束2023-03-2017.【学习笔记】长链剖分2023-04-2218.【学习笔记】2-SAT2023-04-2319.【学习笔记】根号算法2023-06-06

20.【学习笔记】Primal-Dual 原始对偶算法2023-06-15

21.【学习笔记】Bostan-Mori 算法2023-07-0222.【学习笔记】狄利克雷卷积与高级筛法2023-07-0323.【学习笔记】DP 优化 1：基础优化2023-07-0324.【学习笔记】DP 优化 2：动态 DP2023-07-0425.【学习笔记】李超线段树2023-07-0926.【学习笔记】优化建图2023-07-1127.【学习笔记】Segment Tree Beats2023-07-1128.【学习笔记】插头 DP2023-07-1329.【学习笔记】任意模数多项式乘法2023-07-1630.【学习笔记】SG 函数与 SG 定理2023-08-0531.【学习笔记】类欧几里得算法2023-08-0632.【学习笔记】狄利克雷前/后缀和/差分2023-08-1133.【学习笔记】DSU on Tree2023-08-2234.【学习笔记】DP 优化 3：闵可夫斯基和优化 DP2023-09-0135.【学习笔记】笛卡尔树2023-09-0536.【学习笔记】Miller-Rabin 算法2023-10-2437.【学习笔记】DP 优化 4：决策单调性2023-11-1538.【学习笔记】DP 优化 5：wqs 二分优化 DP2023-12-0439.【学习笔记】边分治2023-12-2840.【学习笔记】KMP 相关算法2024-01-1041.【学习笔记】概率生成函数2024-01-1142.【学习笔记】离散对数和剩余2024-01-25

收起

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}$，最短路值应该是：

$$d'(p_1,p_n)=(d(p_1,p_2)+h_{p_1}-h_{p_2})+\cdots+(d(p_{n-1},p_n)+h{p_{n-1}}+h_{p_n})=d(p_1,p_n)+h_{p_1}-h_{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];
    }
}