图论总结模板

最新推荐文章于 2024-05-05 20:37:09 发布
最新推荐文章于 2024-05-05 20:37:09 发布
阅读量680 收藏 2
点赞数
分类专栏： Summary 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DoJintian/article/details/51427493
版权

图论

DAG : Directed Acyclic Graph 无回路有向图

最短路

Dijkstra

你一直困惑的原因是你忽略了dijkstra算法的思想每次利用优先队列找出d值最小的节点然后从该节点出发更新该节点边上的节点这样的话 如果d值小于p.first 说明之前的操作中已经该节点已经被更新，而且更新之后的节点存在于后面的队列中 故此处无需考虑 如果d值不小于p.first 说明d值等于p.fist 即表明之前的操作中没有被更新,故此处可以进行对与其相邻元素的更新工作

struct edge {int to， cost; };
typedef pair<int , int> P;///first 是最短距离 second 是顶点编号
vector<edge> G[maxn];
int d[maxn];///到某个顶点的最短距离
void dijkstra(int s)
{
    priority_queue<P, vector<P>, greater<P> >que;
    fill(d, d+N, INF);
    d[s] = 0;
    que.push(P(0 , s));
    while(!que.empty())
    {
        P p = que.top();
        que.pop();
        int v = p.second;
        if(d[v] < p.first) continue;///否则就要更新与p.second接壤的节点
        for(int i=0; i<G[v].size(); i++)
        {
            edge e = G[v][i];
            if(d[e.to] > d[v] + e.cost)
            {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

次短路

struct edge {int to， cost; };
typedef pair<int,int> P;
int V;
vector<edge> G[maxn];
int d[maxn];//最短路
int d2[maxn];//次短路
void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> >q;
    for(int i=0; i<V; ++i)
    {
        d[i]=INF;
        d2[i]=INF;
    }
    d[s]=0;
    q.push(P(d[s],s));
    while(!q.empty())
    {
        P p = q.top();
        q.pop();
        int v = p.second,c=p.first;
        if(d2[v]<p.first)continue;
        for(int i=0; i<G[v].size(); ++i)
        {
            edge e = G[v][i];
            int c2 = c+e.w;//新的权值
            if(d[e.to]>c2) //维护最短路
            {
                swap(d[e.to],c2);
                q.push(P(d[e.to],e.to));
            }
            if(d2[e.to]>c2&&d[e.to]<c2) //维护次短路
            {
                d2[e.to]=c2;
                q.push(P(d2[e.to],e.to));
            }
        }
    }
}

Floyd

int n;
int d[maxn][maxn];

void Floyd()
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        d[i][j] = (i==j ? 0 : INF);

    for(int k=1; k<=n; k++)
        for(int i=1; i<=n; i++)
           for(int j=1; j<=n; j++)
        d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
}

Bellman-Ford—-SPFA

struct Edge
{
    int v, w, next;
}edge[maxn*20]//边数根据具体情况而定

int n, m, tot;
int dist[maxn], head[maxn];
bool vis[maxn];

void add_edge(int u, int v, int w)
{
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void  SPFA(int s)
{
    memset(vis, false, (n+2)*sizeof(bool));
    for(int i=1; i<=n; i++)  dist[i] = INF;

    vis[s] = true;
    dist[s] = 0;
    queue<int> Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        vis[u] = false;//重要点一
        for(int j=head[u]; j!=-1; j=edge[j].next)
        {
            int v = edge[j].v;
            int w = edge[j].w;
            if(dist[u] < INF && dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;//重要点二
                    Q.push(v);
                }
            }
        }
    }
}

二分图匹配

无权图匹配（匈牙利算法） O(n*n)

#include <bits/stdc++.h>

using namespace std;
#define maxn 1000

vector<int>G[maxn];
bool vis[maxn];
int link[maxn];
int n, m;

bool Find(int u)
{
    for(int i=0; i<G[u].size(); i++)
    {
        int &v = G[u][i];
        if(!vis[v])
        {
            vis[v] = true;
            if(link[v]==-1 || Find(link[v]))
            {
                link[v] = u;
                link[u] = v;//这个地方要注意，无向图，区别于两组对象
                return true;
            }
        }
    }
    return false;
}

void solve()
{

    int ans = 0;
    for(int i=1; i<=n; i++)
    if(link[i]==-1)///这里需要加上判断 否则对已经匹配好的进行重新匹配，造成错误结果
    {
        memset(vis, 0, sizeof(vis));
        if(Find(i))  ans++;
    }
    printf("%d\n", ans);
}

HK O((n ^ 1/2) * m )

带权图匹配(KM) (O(m*m*n))

const int N = 310;
const int INF = 0x3f3f3f3f;
int nx,ny;//两边的点数
int g[N][N];//二分图描述  坐标点为 0 ~ n - 1
int linker[N],lx[N],ly[N];//y中各点匹配状态，x,y中的点标号
int slack[N];
bool visx[N],visy[N];
bool DFS(int x)
{
    visx[x] = true;
    for(int y = 0; y < ny; y++)
    {
        if(visy[y])continue;
        int tmp = lx[x] + ly[y] - g[x][y];
        if(tmp == 0)
        {
            visy[y] = true;
            if(linker[y] == -1 || DFS(linker[y]))
            {
                linker[y] = x;
                return true;
            }
        }
        else if(slack[y] > tmp)
            slack[y] = tmp;
    }
    return false;
}
int KM()
{
    memset(linker,-1,sizeof(linker));
    memset(ly,0,sizeof(ly));
    for(int i = 0; i < nx; i++)
    {
        lx[i] = -INF;
        for(int j = 0; j < ny; j++)
            if(g[i][j] > lx[i])
                lx[i] = g[i][j];
    }
    for(int x = 0; x < nx; x++)
    {
        for(int i = 0; i < ny; i++)
            slack[i] = INF;
        while(true)
        {
            memset(visx,false,sizeof(visx));
            memset(visy,false,sizeof(visy));
            if(DFS(x))break;
            int d = INF;
            for(int i = 0; i < ny; i++)
                if(!visy[i] && d > slack[i])
                    d = slack[i];
            for(int i = 0; i < nx; i++)
                if(visx[i])
                    lx[i] -= d;
            for(int i = 0; i < ny; i++)
            {
                if(visy[i])ly[i] += d;
                else slack[i] -= d;
            }
        }
    }
    int res = 0;
    for(int i = 0; i < ny; i++)
        if(linker[i] != -1)
            res += g[linker[i]][i];
    return res;
}

最大团

详细讲解

网络流

最大流

原理：在残量网络上不断贪心的进行增广（最小割最大流）

1. 简单增广路 （ nm2 )
struct Edge
{
    int from, to, cap, flow;
    Edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f){}
};

int n, m;
vector<Edge> edges;
vector<int> G[maxn];
int a[maxn];
int p[maxn];

void init()
{
    for(int i=0; i<n; i++)
        G[i].clear();
    edges.clear();
}

void AddEdge(int from, int to, int cap)
{
    edges.push_back(Edge(from, to, cap, 0));
    edges.push_back(Edge(to, from, 0, 0));
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

int Maxflow(int s, int t)
{
    int flow = 0;
    for(;;)
    {
        memset(a, 0, sizeof(a));
        queue<int> Q;
        Q.push(s);
        a[s] = INF;
        while(!Q.empty())
        {
            int x = Q.front(); Q.pop();
            for(int i=0; i<G[x].size(); i++)
            {
                Edge& e = edges[G[x][i]];
                if(!a[e.to] && e.cap > e.flow)
                {
                    p[e.to] = G[x][i];
                    a[e.to] = min(a[x], e.cap - e.flow);
                    Q.push(e.to);
                }
            }
            if(a[t]) break;
        }
        if(!a[t]) break;
        for(int u=t; u!=s; u=edges[p[u]].from)
        {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
        }
        flow += a[t];
    }
    return flow;
}
2. Dinic ( mn2 )
  • 分层图
  • 阻塞流

测试题 HDU 1532

struct Edge
{
    int u, v, c, next;
}e[E<<2];

int n, m, s, t;
int d[V], head[V], cnt;//注意head在主函数的需要初始化

void adde(int u, int v, int c)//添加一条有向边，如果是无向边需添加两次
{
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].c = c;
    e[cnt].next = head[u];
    head[u] = cnt++;

    e[cnt].u = v;
    e[cnt].v = u;
    e[cnt].c = 0;
    e[cnt].next = head[v];
    head[v] = cnt++;
}

int bfs()//构造层次图
{
    memset(d, -1, (n+3)*sizeof(int));
    d[s] = 0;
    queue<int> Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for(int i=head[u]; i!=-1; i=e[i].next)
        {
            int v = e[i].v;
            if(d[v]==-1 && e[i].c>0)
               {
                   d[v] = d[u] + 1;
                   Q.push(v);
               }
        }
    }
    return d[t] != -1;
}

int dfs(int x, int a)//寻找最短增广路
{
    if(x==t || a==0) return a;
    int flow = 0, f;
    for(int i=head[x]; i!=-1 && flow<a; i=e[i].next)
    {
        int v = e[i].v;
        if(d[v]==d[x]+1 && e[i].c>0)
        {
            int t = min(e[i].c, a-flow);
            f = dfs(v, t);
            flow += f;
            e[i].c -= f;
            e[i^1].c += f;
        }
    }
    if(!flow)  d[x] = -2;
    return flow;
}

int dinic(int s, int t)//不断进行构造层次图，然后寻找最短增广路，找出最大流
{
    int flow = 0, f;
    while(bfs())
    {
        while(f = dfs(s, INF))
        flow += f;
    }
    return flow;
}
3. ISPA

费用流

原理：在残量网络上总是沿着最短路进行增广（将费用当做距离来进行考虑）

如果要考虑流量f固定之下的最小费用，可以加一条容量为f从源点出发的边

#define MOD 0x3f3f3f3f
#define V 1000 + 10  //边数
#define E 10000 + 10 //点数
int n, m, flow_sum;// 点数 边数 总流量
bool vis[V];
int cnt, dist[V], head[V], pre[V];
struct Edge
{
    int u, v, c, cost, next;//This 'c' means capacity
} edge[E<<2];
void init()
{
    cnt = flow_sum = 0;
    memset(head, -1, (n+3) * sizeof(int));
}
void adde(int u, int v, int c, int cost)
{
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].c = c;
    edge[cnt].cost = cost;
    edge[cnt].next = head[u];
    head[u] = cnt++;
    edge[cnt].u = v;
    edge[cnt].v = u;
    edge[cnt].c = 0;
    edge[cnt].cost = -cost;
    edge[cnt].next = head[v];
    head[v] = cnt++;
}
bool spfa(int begin, int end)
{
    int u, v;
    queue<int> q;
    memset(pre, -1, (n+3)*sizeof(int));
    memset(vis, 0, (n+3)*sizeof(bool));
    memset(dist, 0x3f, (n+3)*sizeof(int));
    vis[begin] = 1;
    dist[begin] = 0;
    q.push(begin);
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        vis[u] = false;
        for(int i=head[u]; i!=-1; i=edge[i].next)
            if(edge[i].c > 0)
            {
                v = edge[i].v;
                if(dist[v] > dist[u] + edge[i].cost)
                {
                    dist[v] = dist[u] + edge[i].cost;
                    pre[v] = i;
                    if(!vis[v])
                    {
                        vis[v] = true;
                        q.push(v);
                    }
                }
            }
    }
    return dist[end] != MOD;
}

int MCMF(int begin, int end)
{
    int ans = 0, flow;
    while(spfa(begin, end))
    {
        flow = MOD;
        for(int i=pre[end]; i!=-1; i=pre[edge[i].u])
            flow = min(flow, edge[i].c);
        for(int i=pre[end]; i!=-1; i=pre[edge[i].u])
        {
            edge[i].c -= flow;
            edge[i^1].c += flow;
        }
        ans += dist[end] * flow;
        flow_sum += flow;
    }
    return ans;//返回最小费用
}
阿龙的圈子
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数学建模常用算法（Python 程序及数据）- 图论模型.zip
04-29
数学建模常用算法（Python 程序及数据）- 图论模型
【蓝桥模板】——大话Python数据结构·最短路径（最短路径模板）
小蓝
02-13 2774
小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图中的最短路径。 小蓝的图由 2021 个结点组成，依次编号 1 至 2021。 对于两个不同的结点 a, b，如果 a 和 b 的差的绝对值大于 21，则两个结点之间没有边相连；如果 a 和 b 的差的绝对值小于等于 21，则两个点之间有一条长度为 a 和 b 的最小公倍数的无向边相连。 例如：结点 1 和结点 23 之间没有边相连；结点 3 和结点 24 之间有一条无向边，长度为 24；结点 15 和结点 25 之间有一条无向边，长度
数据结构 图 Dijkstra算法
你若盛开 清风自来
08-29 499
#include #include #include #include #include using namespace std; const int maxn = 1024; const int INF = 0x7fffffff; typedef pair P; //到这个点的最短路长度 和这个点 int ans; struct edge //边的终点 和长度 { int
python 表示图论_python 图论算法（1）
weixin_39710951的博客
12-09 530
python 图论算法(一)学习Python有一段时间了，看了几本书，大部分时间都是拿它写一些小的脚本，处理数据，最近用Python实现了几个常见的图论算法。第一部分就是图的存储和建立。方法一，用矩阵存储。所谓矩阵就是二维数组。Python的二维数组用起来更加随意和简单。写了一个很low的控制台输入建立图的方法。一时间也没想起其他好的方法。用二维数组存储，对算法的实现很有帮助。def buildg...
图论模板总结
qq_43085783的博客
09-09 129
图论
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
新手总结的部分图论模板，可能做得不是很好，请大家谅解~~
ACM常用模板总结ACM常用模板总结
07-18
图论_NP搜索\ 最大团(n小于64) 最大团 图论_连通性\ 无向图关键边(dfs邻接阵形式) 无向图关键点(dfs邻接阵形式) 无向图块(bfs邻接阵形式) 无向图连通分支(bfs邻接阵形式) 无向图连通分支(dfs邻接阵形式) 有...
acm模板,自己总结
06-04
私人模板,自己写的,有图论等基础知识,适用于省赛..............................................................................................................................................................
ACM经典模板.rar
01-20
包含各位大神（Kuangbin、浙大）总结的的ACM模板，内容覆盖字符串处理、数学基础、数据机构、图论、搜索、DP、计算几何等知识，非常不错！
leetcode16-3Sum Closest
我的程序人生
04-29 398
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
c++容器与算法概述
北风
05-01 535
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
代码随想录算法训练营第三十八天
weixin_41902984的博客
04-28 349
又又又欠两天债，不过回家了，一切可以按部就班，明天慢慢补吧，今天先做一课的内容。然后就是如果一次可以上m个阶梯的话应该怎么做，先把伪代码放上来。其实就是斐波那契数，不过需要理解一下过程。还好还好，动态规划第一天不太难。746. 使用最小花费爬楼梯。509. 斐波那契数。
【算法】高精度乘法
m0_73209194的博客
05-02 449
高精度乘法
【算法刷题 | 贪心算法08】4.29（划分字母区间、合并区间）
踢桃的成长之路
04-29 821
4.29（划分字母区间、合并区间）
学习选择排序的可视化实现（一）
weixin_40539956的博客
05-03 421
开始：从数组的第一个元素开始，假设最小（或最大）元素就是第一个元素。比较：遍历未排序的部分，找到实际的最小（或最大）元素。交换：将找到的最小（或最大）元素与未排序部分的第一个元素交换位置。重复：移动到下一个元素，重复步骤2和3，直到数组完全排序。
【算法】滑动窗口——长度最小的子数组
最新发布
2302_79031646的博客
05-05 478
本篇文章是用一个实例来介绍常用算法之一“滑动窗口”的相关概念，有需要借鉴即可。
c++ 筛选裁决文书 1985-2021的数据 分析算法的差异
qq_49758204的博客
05-03 220
c++ cpp 并行计算筛选过滤 裁决文书网1985-2021 的300g数据
图论bfs算法模板实现c++
08-14
当然，下面是一个基本的图论 BFS 算法的 C++ 实现模板： ```cpp #include #include #include using namespace std; // 图的邻接表表示 vector<vector<int>> graph; // BFS 函数 void bfs(int start) { // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值