Dinic笔记

已于 2022-03-11 14:42:45 修改
阅读量509 收藏 1
点赞数
分类专栏： 《算法训练营》进阶篇读书笔记 图论 文章标签： 动态规划 贪心算法 算法
于 2021-11-28 00:56:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_eeking/article/details/121569944
版权

Dinic

算法思想

Dinic相对于EK算法，更注重点的使用，Dinic算法首先BFS搜索将图进行分层，然后DFS沿着层次+1且 c a p > f l o w cap>flow cap>flow的方向寻找增广路，回溯时增流，

算法步骤

  1. BFS残余网络，分层
  2. 在层次图DFS，DFS沿着层次+1且 c a p > f l o w cap>flow cap>flow的方向找增广路，回溯增流
  3. 重复步骤，直到不存在增广路

在DFS过程中，设搜索的当前节点为 i i i，当到达 i i i时，有一个预值 f l o w flow flow作为 i i i可增流的总值，也就是说，尽量使所有 i i i的深层邻接点凑出这个 f l o w flow flow，深层邻接点的增流被汇总到 i i i，有些类似于累和，具体可见代码

Dinic执行时每次要重新分层，从源点到汇点的层次严格升序，设带权有向图中有 V V V个点，最多就有 V V V层，所以最多重新分层 V V V次，设每次遍历的边数为 E ( E ≤ 边 总 数 ) E(E\le边总数) E(E≤边总数)，则最后的时间复杂度为 O ( V 2 E ) O(V^2E) O(V2E)

代码实现

bool BFS(int s,int t) {//分层
    memset(d,0,sizeof(d));
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {//如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=head[u]; ~i&&res; i=e[i].next) {//遍历满足条件的邻边并增流
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k){d[v]=0;continue;}
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
    int ans=0;//存储最大流
    while(BFS(s,t))ans+=DFS(s,inf,t);
    return ans;
}

结果输出

对于Dinic算法来说，最后一次的循环其实没有进行增流，它只是确定了没有不能再继续增流了，那么所需要的最大流中的所有节点一定被分层了，换言之，如果要输出答案，只需要找到有分层的点即可

当前弧优化

每次增广了一条路之后，由于是最大流，所以这条路必然没有了增广的必要，也没有多余的流量可增广，那么每次扫描的时候可以跳过这些无法增广的边，因此可以记录已经增广到哪条边了，下一次如果碰到同样的节点则直接从这条边开始增广，具体如图，对于节点2，如果2,3和2,4已经增流过了，其实之后的扫描就没有必要再访问了，这个时候如果开一个数组记录对于节点2当前访问的哪条边，这样的话就能减少不必要的扫描
在这里插入图片描述

代码

bool BFS(int s,int t) {//分层
    memset(d,0,sizeof(d));
    for(int i=0; i<=n+1; i++)//复制每个点的head，一定一定要注意节点的个数
        cur[i]=head[i];
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {//如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=cur[u]; ~i&&res; i=e[i].next) {//遍历满足条件的邻边并增流
        cur[u]=i;//当前弧优化
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k) {
                d[v]=0;
                continue;
            }
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
    int ans=0;//存储最大流
    while(BFS(s,t))ans+=DFS(s,inf,t);
    return ans;
}

训练

LuoguP3376

题目大意：略

思路：最大流模板题

代码

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=205;
const int maxn=1e4+10;
const int inf=0x3f3f3f3f;
int head[N],n,m,s,t,cnt,cur[N],d[N];
struct node {
    int to,next,cap,flow;
} e[maxn];
void Add(int from,int to,int cap,int flow) {
    e[cnt].to=to;
    e[cnt].next=head[from];
    e[cnt].cap=cap;
    e[cnt].flow=flow;
    head[from]=cnt++;
}
bool BFS(int s,int t) {//分层
    memset(d,0,sizeof(d));
    for(int i=0; i<=n+1; i++)//复制每个点的head
        cur[i]=head[i];
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {//如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=cur[u]; ~i&&res; i=e[i].next) {//遍历满足条件的邻边并增流
        cur[u]=i;//当前弧优化
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k) {
                d[v]=0;
                continue;
            }
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
    int ans=0;//存储最大流
    while(BFS(s,t))ans+=DFS(s,inf,t);
    return ans;
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >>n>>m>>s>>t;
    memset(head,-1,sizeof(head));
    while(m--) {
        int u,v,w;
        cin >>u>>v>>w;
        Add(u,v,w,0);
        Add(v,u,0,0);
    }
    cout <<Dinic(s,t);
    return 0;
}

POJ1149

题目大意：M个猪圈，每个猪圈有初始数量，依次来N个人，每个人可以打开指定的猪圈，购买若干头猪，每个人有一个购买上限，每个人购买完后，猪圈不会立刻关上，管理员可以重新分配已打开的猪圈的猪，分配完后关闭猪圈等待下一个人，求出最多能卖出多少猪

思路：可以看到，如果没有购买次序之间的限制，每个猪圈都可以视为源点，客户设置为汇点，那么可以用一个超级汇点作为所有用户最后的汇点，容量为购买数量，在考虑购买次序之间的限制的情况下，设置一个源点，将源点和每个猪圈的第一个人连边，容量为开始时猪圈猪的数量，因为第一个人才能打开这个猪圈，使得猪圈内猪的数量能发生变化，若两个人先后打开一个相同的猪圈，则连边两人编号，容量为无穷大，因为两人能使猪圈内猪的数量变化

代码

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int maxn=1e4;
const int inf=0x3f3f3f3f;
int head[maxn],cnt=0,d[maxn],n,m,init[maxn],last[maxn];
struct node {
    int to,next,cap,flow;
} e[maxn];
void Add(int from,int to,int cap,int flow) {//构造边
    e[cnt].to=to;
    e[cnt].next=head[from];
    e[cnt].cap=cap;
    e[cnt].flow=flow;
    head[from]=cnt++;
}
bool BFS(int s,int t) {//分层
    memset(d,0,sizeof(d));
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {//如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=head[u]; ~i&&res; i=e[i].next) {//遍历满足条件的邻边并增流
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k)d[v]=0;
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
    int ans=0;//存储最大流
    while(BFS(s,t))for(int i=1; i<=n; i++)ans+=DFS(s,inf,t);
    return ans;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >>m>>n;
    for(int i=1; i<=m; i++)cin >>init[i];
    memset(head,-1,sizeof(head));
    for(int i=1; i<=n; i++) {
        int a,b;
        cin >>a;
        while(a--) {
            int k;
            cin >>k;
            if(last[k]==0) {//第一次访问
                last[k]=i;//记录上一层访问的客户
                Add(0,i,init[k],0);//与源点相连
                Add(i,0,0,0);
            } else {
                Add(last[k],i,inf,0);
                Add(i,last[k],0,0);
                last[k]=i;//更新上一个访问者
            }
        }
        cin >>b;
        Add(i,n+1,b,0);//需求与汇点相连
        Add(n+1,i,0,0);
    }
    cout <<Dinic(0,n+1);
    return 0;
}

POJ1459

题目大意：略

思路：根据给出的条件建立对应的边，输电线直接建边，消费用户与汇点连接，发电厂与源点连接，最后跑最大流即可

代码

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int maxn=3e4;
const int inf=0x3f3f3f3f;
int n,np,nc,m,d[maxn],head[maxn],cnt;
struct node {
    int next,to,cap,flow;
} e[maxn];
void Add(int from,int to,int cap,int flow) {
    e[cnt].to=to;
    e[cnt].next=head[from];
    e[cnt].flow=flow;
    e[cnt].cap=cap;
    head[from]=cnt++;
}
bool BFS(int s,int t) {//分层
    memset(d,0,sizeof(d));
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(!d[v]&&e[i].cap>e[i].flow) {//如果可以增流
                d[v]=d[u]+1;
                q.push(v);
                if(v==t)return 1;
            }
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;//res存储当前节点的可增流值
    for(int i=head[u]; ~i&&res; i=e[i].next) {//遍历满足条件的邻边并增流
        int v=e[i].to;
        if(d[v]==d[u]+1&&e[i].cap>e[i].flow) {
            int k=DFS(v,min(res,e[i].cap-e[i].flow),t);//获得最小的回溯流
            if(!k)d[v]=0;
            e[i].flow+=k;//获得最小的回溯流后增流
            e[i^1].flow-=k;
            res-=k;//可增流值减少，因为已经有邻边增流
        }
    }
    return flow-res;//返回实际的总增流值
}
int Dinic(int s,int t) {
    int ans=0;//存储最大流
    while(BFS(s,t))for(int i=1; i<=n; i++)ans+=DFS(s,inf,t);
    return ans;
}
int main() {
    while(cin >>n>>np>>nc>>m) {
        memset(head,-1,sizeof(head));
        cnt=0;
        char ch;
        int u,v,z;
        while(m--) {
            cin >>ch>>u>>ch>>v>>ch>>z ;
            Add(u,v,z,0);
            Add(v,u,0,0);
        }
        while(np--) {
            cin >>ch>>u>>ch>>z;
            Add(n+1,u,z,0);
            Add(u,n+1,0,0);
        }
        while(nc--) {
            cin >>ch>>u>>ch>>z;
            Add(u,n+2,z,0);
            Add(n+2,u,0,0);
        }
        cout <<Dinic(n+1,n+2)<<endl;
    }
    return 0;
}

HDU3549

题目大意：给出一个有向带权图，求解最大流

思路：本题是最大流模板题，直接使用即可

代码

#include <bits/stdc++.h>
const int maxn=1e4+10;
const int inf=0x3f3f3f3f;
using namespace std;
int head[maxn],cnt,d[maxn],T,n,m;
bool vis[maxn];
struct node {
    int next,to,cap,flow;//链式前向星，容量和流
} e[maxn];
void Add(int from,int to,int cap,int flow) {
    e[cnt].next=head[from];
    e[cnt].cap=cap;
    e[cnt].flow=flow;
    e[cnt].to=to;
    head[from]=cnt++;
}
bool BFS(int s,int t) {
    memset(d,0,sizeof(d));
    queue<int>q;
    q.push(s);
    d[s]=1;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(d[v]||e[i].cap<=e[i].flow)continue;
            d[v]=d[u]+1;
            q.push(v);
            if(v==t)return 1;
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;
    for(int i=head[u]; ~i&&res; i=e[i].next) {
        int v=e[i].to;
        if(d[v]!=d[u]+1||e[i].cap<=e[i].flow)continue;
        int k=DFS(v,min(res,e[i].cap-e[i].flow),t);
        if(!k)d[v]=0;
        e[i].flow+=k;
        e[i^1].flow-=k;
        res-=k;
    }
    return flow-res;
}
int Dinic(int s,int t) {
    int ans=0;
    while(BFS(s,t))for(int i=1; i<=n; i++)ans+=DFS(s,inf,t);
    return ans;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >>T;
    for(int i=1; i<=T; i++) {
        memset(head,-1,sizeof(head));
        cnt=0;
        cin >>n>>m;
        while(m--) {
            int x,y,c;
            cin >>x>>y>>c;
            Add(x,y,c,0);
            Add(y,x,0,0);//存反边，容量和流均为0
        }
        cout <<"Case "<<i<<": ";
        cout <<Dinic(1,n)<<endl;
    }
    return 0;
}

HDU1532

题目大意：略

思路：最大流模板题

代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e3;
const int inf=0x3f3f3f3f;
int head[maxn],cnt,d[maxn],n,m;
bool vis[maxn];
struct node {
    int next,to,cap,flow;
} e[maxn];
void Add(int from,int to,int cap,int flow) {
    e[cnt].to=to;
    e[cnt].next=head[from];
    e[cnt].flow=flow;
    e[cnt].cap=cap;
    head[from]=cnt++;
}
bool BFS(int s,int t) {
    memset(d,0,sizeof(d));
    queue<int>q;
    d[s]=1;
    q.push(s);
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=head[u]; ~i; i=e[i].next) {
            int v=e[i].to;
            if(d[v]||e[i].cap<=e[i].flow)continue;
            d[v]=d[u]+1;
            q.push(v);
            if(v==t)return 1;
        }
    }
    return 0;
}
int DFS(int u,int flow,int t) {
    if(u==t)return flow;
    int res=flow;
    for(int i=head[u]; ~i&&res; i=e[i].next) {
        int v=e[i].to;
        if(d[v]!=d[u]+1||e[i].cap<=e[i].flow)continue;
        int k=DFS(v,min(res,e[i].cap-e[i].flow),t);
        if(!k)d[v]=0;
        e[i].flow+=k;
        e[i^1].flow-=k;
        res-=k;
    }
    return flow-res;
}
int Dinic(int s,int t) {
    int ans=0;
    while(BFS(s,t))for(int i=1; i<=m; i++)ans+=DFS(s,inf,t);
    return ans;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    while(cin >>n>>m) {
        memset(head,-1,sizeof(head));
        cnt=0;
        while(n--) {
            int s,e,c;
            cin >>s>>e>>c;
            Add(s,e,c,0);
            Add(e,s,0,0);
        }
        cout <<Dinic(1,m)<<endl;
    }
    return 0;
}

总结

Dinic算法的时间复杂度与图上的节点有关，以后涉及到图论相关的问题需要考虑是以点为基准还是以边为基准来选择不同的算法，做题的时候才不会做无用功

参考文献

  1. [蒟蒻算法小课堂 3] Dinic算法的基本实现及优化
  2. Dinic当前弧优化 模板及教程
C_eeking
关注
专栏目录
网络流算法学习笔记——Dinic有效算法
zhang35的博客
04-27 1159
Dinic有效算法同样用来求最大流，相当于FF算法的改进。 FF算法参考：网络流算法学习笔记——最大流问题基本概念和Ford-Fulkerson方法（标号法C++实现） 改进之处有： FF算法每次只找1条s-t增广链，而Dinic算法每次能找很多条 Dinic算法每次都找最短的（边数最少的）s-t增广链（为啥呢？ ） ...
学习笔记或者说叫做算法板子吧：DINIC（最大流算法）
少主大人殿下的博客
02-01 357
简述 这是一个奇怪的操作了，因为很多时候又比ISAP慢代码又长，不过最坏时间复杂度是相同的，但是DINIC并没有因为ISAP而被淘汰，说明在很多时候有他自己的优势，因此还是要学一下，或者可以帮助更好的理解一下ISAP吧。 好的我知道了，这个东西可以动态加流量然后接着跑，但是ISAP就不可以了，不过ISAP有可能快到不动态都能过。。。 原理 “层次图” “阻塞流” 根据当前还有流量的边跑...
Dinic学习笔记
weixin_30648963的博客
04-13 71
网络流是啥不用我说了吧 增广路定理不用我说了吧 Dinic就是分层然后只在层间转移，然后就特别快，\[O(N^2M)\] 伪代码： function dinic int flow = 0 ; while bfs() do memsets() while int val = dfs() do flow += val; r...
Dinic算法简单笔记
佯设的博客
05-18 337
萌新一枚，借鉴了许多大佬而总结下的笔记，可能有瑕疵或者错误，望指正。 1主要用于求网络最大流问题 思路 1存储图，每条边可以看成一个水管，有容量和流量，流量不能超过容量 循环: 2构造层次网络（level gragh）和残留网络（还有多少水可以流,容量减流量） 3寻找到一个阻塞流，就是不能流更多的水的路径，（最大流是阻塞流，阻塞流不是最大流） 4如果到达不了终点，循环就结束了 5更新残留网络，正向流量加相应的值，答案加相应的值，反向路径的流量减去相应的值（这意味着残留网络中他的权值变大，变化
网络流 dinic 注释笔记
fdxgcw的博客
06-20 77
#include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 10010, M = 200010, inf = 1e8; int n, m, S, T; int h[N], e[M], f[M], ne[M], idx; int q[N], d[N], cur[N]; void add(int a, int b, int c) { e[
网络流 学习笔记
landexiangmz的博客
07-31 749
两种理解：1）最小割=最大流 2）在余量图中找S能到达的所有点为S集，其余点为T集，在原图中将S集与T集做切割，所有S到T的边权和为最小割。题目要求同时求出最小费用最大流和最大费用最小流，最大费用实际上就是将边权置为负值，跑最小费用最大流即可。假设有 n 根柱子，现要按下述规则在这 n 根柱子中依次放入编号为 1，2，3，...的球“1.找到一条从源点到终点的简单路径，将这条路径上的最小值视为该条路径的流量，更新原图。2.不断找从源点到终点的简单路径，进行更新，直到再也找不到，最终可以得到汇点的权值。
最大流笔记
最新发布
DL24yanjun的博客
09-14 167
每确定一条边时，同时建立一天反方向的边以用来进行反悔操作（毕竟一次性找到正确方案的概率太低了）也是运用bfs进行找边，但统计答案时使用dfs，可大大降低时间复杂度。求两点间的路径中可在同一时间内通过的最大量。通过bfs找通路，找到后回溯；
dinic算法 c 语言,网络流入门—用于最大流的Dinic算法
weixin_33330762的博客
05-23 291
“网络流博大精深”—sideman语一个基本的网络流问题最早知道网络流的内容便是最大流问题，最大流问题很好理解：解释一定要通俗!如右图所示,有一个管道系统,节点{1,2,3,4},有向管道{A,B,C,D,E},即有向图一张. [1]是源点,有无限的水量,[4]是汇点,管道容量如图所示.试问[4]点最大可接收的水的流量?这便是简单的最大流问题,显然[4]点的最大流量为50死理性派请注意:流量是单位...
二分图博弈学习笔记
sophilex的博客
07-22 835
因为黑白棋是轮流操作的，黑棋走过的点白棋是无法走的，反之同理。假设当前P不在最大匹配中，那么先手移动之后P一定会到达一个匹配点，否则我们就有了一个新的匹配，与最大匹配这一点矛盾。每次操作之后整张图都不一样了，我们要判断的起始点也不一样了，所以我们每次要重新建图，因为图比较小，所以该方法是可行的。在该图的残量网络中，1->5的流量为1，匹配边5->2的反向流量为1，因此我们判断两条边可以互换。由此，对于一个二分图博弈，只要我们能够判断先手所在局面是否处在二分图的最大匹配上，即可判断必胜状态。
算法笔记：Dinic最大流和SPFA费用流
Raki_J的博客
06-06 880
先利用BFS对残余网络分层 一个节点的深度，就是源点到它最少要经过的边数。 利用BFS对残余网络分层，分完层后，利用DFS从前一层向后一层反复寻找增广路。 这里写图片描述 分完层后，从源点开始，用DFS从前一层向后一层反复寻找增广路(即要求DFS的每一步都必须要走到下一层的节点）。 因此，前面在分层时，只要进行到汇点的层次数被算出即可停止，因为按照该DFS的规则，和汇点同层或更下一层的节点，是不可能走到汇点的。 DFS过程中，要是碰到了汇点，则说明找到了一条增广路径。此时要增加总流量的值，消减路径上各边的容
天津大学ACM竞赛学习笔记：图论、计算几何与数学精华
同时，还讲解了第K短路的计算、一般图的匹配问题，如 Dinic 最大流算法、Sap 最大流算法和EK最大流算法。此外，还包括混合图的欧拉回路、最大权闭合图、最大密度子图、最小边割集、二分图最小权覆盖集、最优比例生成...
算法小笔记
fanqiliang630的博客
12-28 1026
文章目录0. 算法基础1. 判定问题与优化问题[^1]:1. 状态空间**斐波那契数列:****拨转开关问题:****埃及分数问题:****八数码问题:**数字三角形:一维递推问题: 爬楼梯(求和形式)一维递推问题: 最长上升子序列(最值形式)二维问题: 区间问题 - 最长回文子序列二维问题: 区间问题 - 回文子序列的个数 二维问题: 区间问题 - 最优链乘法二维问题:区间问题 -- 区间最值查询二维问题:区间问题 -- 序列间比较问题树与图上的问题2. 经典算法问题：2.1 归并排序2.2 逆序对个数2
【学习笔记】最小割
C2022lihan的博客
12-04 1583
1.定义
最大流最小割
C_eeking的博客
02-13 2282
最大流最小割 最小割练习题与总结，无定理证明
最小费用最大流
C_eeking的博客
02-23 2142
最小费用最大流 简单讲解MCMF和消圈算法
ISAP笔记
C_eeking的博客
01-29 1206
ISAP算法思想， 主要记录ISAP算法的简单思路与训练题
二分图全解
C_eeking的博客
02-04 1036
二分图相关知识点汇总，包括染色，KM，博弈，匈牙利算法
伸展树(Splay)
C_eeking的博客
09-06 1014
伸展树（Splay） 伸展树的作用范围很广，在某些情况下甚至可以代替线段树，伸展树最突出的特点就是区间操作：区间翻转，区间插入，区间删除，与其他二叉搜索树相比它能使得总体时间效率得到平摊，使得总效率为O(mlog n)，当操作涉及到以区间为单位的位置变动时，就会使用到伸展树
可持久化全解
C_eeking的博客
03-06 610
可持久化数据结构相关， 涉及到主席树，可持久化并查集，可持久化线段树，可持久化平衡树
Dinic算法模板解析与应用
"这篇内容是关于Dinic算法的模板实现，包括了算法的基本结构和关键函数，如初始化、添加边、广度优先搜索（BFS）以及深度优先搜索（DFS）。" Dinic算法是一种用于求解网络最大流问题的高效算法，由以色列计算机科学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值