【图论】模板总结

最新推荐文章于 2022-06-25 23:51:49 发布
最新推荐文章于 2022-06-25 23:51:49 发布
阅读量215 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37953323/article/details/76566222
版权

一、最小生成树。

二、最短路。

三、拓扑排序。

四、最大二分匹配。

五、最大流。

六、最小费用最大流。

一、最小生成树。

        算法实现和思想和最短路类似。

二、最短路。

      

1）Floyed算法 O(N3)
　　简称Floyed(弗洛伊德)算法，是 最简单的最短路径算法，可以计算图中 任意两点间的最短路径。Floyed的时间复杂度是 O (N3)，适用于出现 负边权的情况。 
       memset(maps,127/3,sizeof(maps));
            for(int k = 1; k <= n; k++)
            for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                 if(maps[i][j]>maps[i][k]+maps[k][j])
                    maps[i][j]=maps[i][k]+maps[k][j];  //进行更新

2）Dijkstra算法O （N2）
      用来计算从一个点到其他所有点的最短路径的算法，是一种 单源最短路径算法。也就是说， 只能计算起点只有一个的情况。
      Dijkstra的时间复杂度是 O (N2)，它 不能处理存在负边权的情况。 
int dij(int s,int t)
{
    for(int i=1;i<=n;i++)
        p[i]=g[s][i];
    memset(vis,false,sizeof(vis));
    p[s]=0;vis[s]=true;
    while(1)
    {
        v=-1;
        for(int i=1;i<=n;i++)
            if(!vis[i]&&(v==-1||p[v]>p[i]))
             v=i;
        if(v==-1)break;
        vis[v]=true;
        for(int i=1;i<=n;i++)
            if(!vis[i]&&p[i]>p[v]+g[v][i])
            p[i]=p[v]+g[v][i];
    }
    return p[t];
}
3)SPFA算法O(kE)
主要思想是：
    初始时将起点加入队列。每次从队列中取出一个元素，并对所有与它相邻的点进行修改，若某个相邻的点修改成功，则将其入队。直到队列为空时算法结束。
    这个算法，简单的说就是队列优化的bellman-ford，利用了每个点不会更新次数太多的特点发明的此算法。
    
struct edge
{
    int to,cost;
};
int spfa(int s,int t)
{
    memset(is,false,sizeof(is));
    memset(d,127/3,sizeof(d));
    queue<int> que;
    que.push(s);
    is[s]=true;
    d[u]=0;
    while(!que.empty())
    {
        int u=que.top();que.pop();
        for(int i=0;i<g[u].size();i++)
        {
            edge &e=g[u][i];
            if(d[e.to]>d[u]+e.cost)
            {
                d[e.to]=d[u]+e.cost;
                if(!is[e.to])
                {   is[e.to]=true;
                    que.push(e.to);
                }
            } 
        }
    }
    return d[t];
}

三、拓扑排序。

对一个有向无环图(DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。

 void TopSort(int n)  
{  
    num = 0;  
    for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列  
       if(!degree[i]&&vis[i])  
           Q[num++] = i;  
    for(int i=0;i<num;i++)  
    {  
        //删除从该节点出发的所有边，更新degree数组  
        for(int k = head[Q[i]];k != -1;k = Edge[k].next)  
        {  
            degree[Edge[k].to]--;  
            //如果degree数组为0，说明新的没有前驱的节点找到,加入队列中  
            if(!degree[Edge[k].to])    
               Q[num++] = Edge[k].to;  
        }  
    }  
}

四、最大二分匹配。

       结论：

       1.最大匹配+最小边覆盖=V （无孤立点）

       2..最大独立集+最小顶点覆盖=V  （在G中两两互不相连的定点集合）

       3.最大匹配=最小顶点覆盖 （对于二分图）

       4.最小路径覆盖+最大匹配=V  （对于一个DAG图）

       5.最大闭合权子图=总正权值-最大流（s连所有正，所有负连t）   （点数为s在的最小割）

    1)匈牙利算法 O(V*E)

vector<int> g[11111];
int my[33311],n,m;
bool visy[11111];
bool dfs(int x)
{
    for(int i=0;i<g[x].size();i++)
    {
        int y=g[x][i];
        if(visy[y])continue;
        visy[y]=true;
        if(my[y]==-1||dfs(my[y]))
        {
            my[y]=x;
            return true;
        }
    }
    return false;
}
int solve()
{
    int ret=0;
    memset(my,-1,sizeof(my));
    for(int i=1;i<=n;i++)
    {
        memset(visy,false,sizeof(visy));
        if(dfs(i))ret++;
    }
    return ret;
}

   2)HK算法 （优化的匈牙利）O( sqrt(V)*E ) 

vector<int> g[3003];
int mx[3003],my[3003],dx[3003],dy[3003],dis,n,m;
bool vis[3003];
int bfs()
{
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    queue<int> que;
    for(int i=1;i<=n;i++)
        if(mx[i]==-1)
    {
        que.push(i);
        dx[i]=0;
    }
    while(!que.empty())
    {
        int x=que.front();que.pop();
        if(dx[x]>dis)break;
        for(int i=0;i<g[x].size();i++)
        {    int y=g[x][i];
             if(dy[y]!=-1)continue;

            dy[y]=dx[x]+1;
            if(my[y]==-1)dis=dy[y];
            else
            {
                dx[my[y]]=dy[y]+1;
                que.push(my[y]);
            }
        }
    }
    return dis!=INF;
}
int dfs(int x)
{
    for(int i=0;i<g[x].size();i++)
    {int y=g[x][i];
       if(vis[y]||dy[y]!=dx[x]+1)continue;
        vis[y]=true;
        if(my[y]!=-1&&dy[y]==dis)continue;
        if(my[y]==-1||dfs(my[y]))
        {
            my[y]=x;
            mx[x]=y;
            return 1;
        }
    }
    return 0;
}
int max_macth()
{
    int ret=0;
    memset(my,-1,sizeof(my));
    memset(mx,-1,sizeof(mx));
    while(bfs())
    {
        memset(vis,false,sizeof(vis));
        for(int i=1;i<=n;i++)
            if(mx[i]==-1&&dfs(i))ret++;
    }
    return ret;
}

五、二分图最大权完备匹配

 1）KM算法 O（V*V*V）

   

const int INF=0x3f3f3f3f;
const int N=26;
int g[N][N],cx[N],cy[N],n,m,k,lik[N],lack;
bool visx[N],visy[N];
bool find(int x)
{
    visx[x]=true;
    for(int y=0;y<N;y++)
    {
        if(visy[y])continue;

        int t=cx[x]+cy[y]-g[x][y];
        if(!t)
        {   visy[y]=true;
            if(lik[y]==-1||find(lik[y]))
            {
                lik[y]=x;
                return true;
            }
        }
        else
            lack=min(lack,t);
    }
    return false;
}

int km()
{
    memset(lik,-1,sizeof(lik));
    memset(cx,0,sizeof(cx));
    memset(cy,0,sizeof(cy));
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
          cx[i]=max(cx[i],g[i][j]);
    for(int i=0;i<N;i++)
    {
        while(1)
        {
            lack=INF;
            memset(visx,false,sizeof(visx));
            memset(visy,false,sizeof(visy));
            if(find(i))break;
            for(int i=0;i<N;i++)
            {
                if(visx[i])cx[i]-=lack;
                if(visy[i])cy[i]+=lack;
            }
        }
    }
    int ans=0;
    for(int i=0;i<N;i++)
       if(lik[i]>=0)
        ans+=g[lik[i]][i];
    return ans;

}


六、最大流。

      1）FF算法

      

const int INF=0x3f3f3f3f;
struct edge
{
    int to,cap, rev;
    edge(int x=0,int y=0,int z=0)
    {
        to=x;cap=y;rev=z;
    }
};
vector<edge> g[111];
bool used[111];
int n,m,s,t;
void add(int from,int to,int cap)
{
    g[from].push_back(edge(to,cap,g[to].size()));
    g[to].push_back(edge(from,0,g[from].size()-1));
}
int dfs(int v,int t,int f)
{
    if(v==t)return f;
    used[v]=true;
    for(int i=0;i<g[v].size();i++)
    {
        edge &e=g[v][i];
        if(used[e.to]||e.cap<=0)continue;
        int d=dfs(e.to,t,min(e.cap,f));
        if(d>0)
        {
            e.cap-=d;
            g[e.to][e.rev].cap+=d;
            return d;
        }
    }
    return 0;
}
int max_flow()
{
    int flow=0;
    while(1)
    {
        memset(used,0,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0)return flow;
        flow+=f;
    }
}

 2）Dinic 算法 更高效 
const int INF=0x3f3f3f3f;
struct edge
{
    int to,cap,rev;
    edge(int x,int y,int z)
    {
        to=x;cap=y;rev=z;
    }
};
vector<edge> g[5111];
int level[5555],iter[5555],n,m,s,sum;
bool vis[5555];
void add(int from,int to,int cap)
{
    g[from].push_back(edge(to,cap,g[to].size()));
    g[to].push_back(edge(from,0,g[from].size()-1));
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    level[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int v=que.front();que.pop();
        for(int i=0;i<g[v].size();i++)
        {
            edge &e=g[v][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t)return f;
    for(int &i=iter[v];i<g[v].size();i++)
    {
        edge &e=g[v][i];
        if(e.cap>0&&level[e.to]>level[v])
        {
            long long d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                g[e.to][e.rev].cap+=(int)d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    long long  flow=0;
    while(1)
    {
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        long long f;
        while(f=dfs(s,t,INF))
        {
            flow+=f;
        }
    }
}

七、最小费用最大流。

const int INF=0x3f3f3f3f;
const int MAXN=66;
struct edge
{
    int to,cap,cost,rev;
    edge(int x,int y,int z,int w)
    {
        to=x;cost=y;cap=z;rev=w;
    }
};
vector<edge> g[MAXN];
int prei[MAXN],prej[MAXN],dist[MAXN],N;
void add(int from,int to,int cost,int cap)
{
    g[from].push_back(edge(to,cost,cap,g[to].size()));
    g[to].push_back(edge(from,-cost,0,g[from].size()-1));
}
int min_cost_flow(int s,int t,int f)
{
    int res=0;
    N=t;
    while(f>0)
    {
      //  cout<<"*";
        for(int i=0;i<=N;i++)
            dist[i]=INF;
        dist[s]=0;
        bool update=true;
        while(update)
        {
            update=false;
            for(int i=0;i<=N;i++)
            {
                if(dist[i]==INF)continue;
                for(int j=0;j<g[i].size();j++)
                {
                    edge &e=g[i][j];
                    if(e.cap>0&&dist[e.to]>dist[i]+e.cost)
                    {
                        dist[e.to]=dist[i]+e.cost;
                        prei[e.to]=i;
                        prej[e.to]=j;
                        update=true;
                    }
                }
            }
        }
           if(dist[t]==INF)return -1;
            int d=f;
            for(int i=t;i!=s;i=prei[i])
            {
                d=min(d,g[prei[i]][prej[i]].cap);
            }
            f-=d;
            res+=d*dist[t];
            for(int i=t;i!=s;i=prei[i])
            {
                edge &e=g[prei[i]][prej[i]];
                e.cap-=d;
                g[i][e.rev].cap+=d;
            }
    }
    return res;
}


tystrwor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现最小费用最大流问题
南 墙
07-26 1万+
1 问题描述 在最大流有多组解时，给每条边在附上一个单位费用的量，问在满足最大流时的最小费用是多少？ 2 解决方案 下面代码所使用的测试数据如下图： package com.liuzhen.practice; import java.util.ArrayList; import java.util.Scanner; public class Main { public static ...
图论模板详细
07-16
根据提供的文件信息，可以推断出该文档是关于图论算法模板的详细内容总结，其中包含了用于解决各种图论问题的C++代码模板。下面将根据文件内容，逐一介绍图论中涉及的重要知识点。 1. 最短路问题： - 单源最短路...
网络流之最大流，Ford-Fulkerson方法
lpls1
01-16 346
过程： f(e):e上已流过的流量 c(e):e上允许流过的最大流量 残余网络：f(e)小于c(e)的边e && 满足f(e)>0的e对应的反向边rev(e)组成的网络 增广路：残余网络上的s–>t路径 求解最大流：就是不断找图中的增广路，每找到一条，更新一次增广路上的各边的流量及其反向边的流量。 板子： public class Main { static int...
【TCO2016】ColorfulPath（平面图最短路转对偶图最小割）
zxyoi_dreamer的博客（不定期诈尸）
09-12 230
传送门 跑最大流的时候加法爆int了，WA了七次。 题意简述： 给一个DAG，记边从aia_iai​到bib_ibi​，边权cic_ici​，要从000走到nnn，求最短路。 保证ai&lt;bia_i&lt;b_iai​<bi​，而且不存在ai&lt;aj&lt;bi&lt;bja_i&lt;a_j&lt;b_i&lt;b_...
洛谷P3386：网络流之二分图匹配，最大流算法
lpls1
02-02 903
二分图：我的理解是，对图中的点集，可分为两个集合U和V，使得两个集合之间存在通路，且集合内部不存在通路。如上图。 匹配：两两不含公共端点的边集合M 最大匹配：边数最多的匹配 完美匹配：最大匹配的匹配数满足2*M=点的总数 二分图匹配：二分图中的匹配 实际上，可将二分图最大匹配问题看作是最大流问题的特殊情况。 最大流方法解决二分图匹配： 将原图中的所有无向边e改为有向边，方向从U到V，容量为1....
【算法笔记】总结 - 网络流 Edmonds-Karp 算法和 dinic 算法
slowlight93的专栏
07-22 1644
边的表示1) 如果要把边单独存在一个buffer里面，并且每条边有一个唯一的编号。 那么通常将正反边存在一起，比如0，1，这样就可以用 id^1 来方便地访问反边了。 2） 也可以对每个节点，存一个 vector<Edge> 其中 rev 是在 to 节点的邻边列表中的编号。 可以只用 cap 记录剩余容量，这样就省掉 flow 了。struct Edge { int to, c
图论模板总结
qq_41729237的博客
08-26 272
图论模板总结单源最短路问题多元最短路问题（待补充）最小生成树spfa求负环有向图强连通分量无向图的双连通分量差分约束最近公共祖先二分图欧拉回路拓扑排序 单源最短路问题 单源最短路有三种算法，分别是朴素的dijistra算法，堆优化的dijidtra算法，和spfa算法 前面两种算法不能解决负权边 朴素版dijistra算法 复杂度：n*n int ne[M],to[M],h[N],w[M]; int cnt; int vis[N]; int dist[N]; void add(int a,int b,in
图论最短路模板总结
c_yy_的博客
05-03 468
图论最短路模板合集，含Floyd，Dijkastra，SPFA，链式前向星
图论复习总结
weixin_52985599的博客
08-05 279
图论复习总结 前端时间为了打比赛所以急急忙忙地把提高课的图论囫囵吞枣的学完了… 然后打完比赛回来在刷一些洛谷上的图论题，发现很多难的图论题还是不会，最多把和提高课里面做过的类似的题给A掉，所以还只是刚入门图论。 想着先把入门图论掌握了，我还没有理解透图论的精髓，只能写写一些做过的题。 一、单源最短路 单源最短路是指，给定一个带权图并给定一个起点，求这个点到其他所有点的最短路径。 一般解题思路： 根据题意建图 根据题目中的限制选择最短路算法 实现最短路算法 输出答案 一般来说，最短路的问题难点在于建图，思
图论模板题及分析
磊哥哥讲算法
06-25 534
算法基础中图论涉及的各种算法详解和模板题拆分理解
图论基本模板总结
weixin_30947043的博客
07-29 66
最短路（vector+Dijkstra优先队列优化） #include<cstdio> #include<iostream> #include<cstring> #include<algorithm> #include<queue> #include<stack> #include<set> ...
ACM图论模板_BY夏天的风
08-10
标题中提到的“ACM图论模板”，意味着这是一个为算法竞赛（ACM国际大学生程序设计竞赛）准备的图论知识整理，这些内容通常被用于快速构建算法原型和解决图论相关问题。夏天的风作为作者的笔名，可能代表了其个人对该...
ACM图论数据结构常见模板
09-26
图论 3 连通性 3 强连通分量 3 割点/割边 7 点/边双联通 9 最短路 && 查分约束 11 Dijkstra 11 SPFA 13 Floyd_Wallshall 14 次短路 15 查分约束 16 2- SAT 17 生成树 18 最小生成树 18 最小树形图 20 拓扑排序 22 ...
ACM新手总结的部分图论模板
12-21
这篇总结将围绕这些核心主题，为新手提供一些基本的图论模板和解题思路。 1. **图的基本概念**：图是由顶点（Vertex）和边（Edge）组成的集合，可以表示各种关系。图分为有向图（Directed Graph, DG）和无向图...
acm 算法及模板总结
01-21
以下是对标题“acm算法及模板总结”中涉及的几个关键知识点的详细解释： 1. **ACM算法**： - **排序算法**：快速排序、归并排序、堆排序等，常用于处理比赛中的数组和序列问题。 - **搜索算法**：深度优先搜索...
超市管理系统，基于javaweb.zip
08-15
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无积分，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于收集和整理资料耗费时间的酬劳
vue3面试题2023,84页，几十道vue面试题，准备vue的面试，这么一份文件就够了
08-15
vue3面试题2023： Vue 的优缺点  优点 1.创建单页面应用的轻量级Web应用框架 2.简单易用 3.双向数据绑定 4.组件化的思想 5.虚拟DOM 6.数据驱动视图 缺点 不支持IE8
【雷达跟踪】基于matlab雷达目标生成与跟踪【含Matlab源码 7220期】.zip
08-15
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
CTR2024中国广告主营销趋势调查报告.pdf
最新发布
08-15
【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2024中国广告主营销趋势调查报告.pdf【CTR】2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值