算法学习——图论

已于 2024-04-09 20:31:20 修改
阅读量169 收藏 3
点赞数 4
文章标签： 算法 学习 图论
于 2024-04-07 15:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OYYHXPJR/article/details/137458725
版权

拓扑排序（BFS的应用）

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1e5+10;
int h[N], e[N], ne[N], idx;
int n,m;
int d[N];
int ans[N],cnt;
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

int topp()
{
    queue<int>q;
    for(int i=1;i<=n;i++)
    {
        if(d[i]==0)q.push(i);
    }
    while(!q.empty())
    {
        int t=q.front();q.pop();
        ans[cnt++]=t;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            d[j]--;//减边的操作
            if(d[j]==0)
            {
                q.push(j);
            }
        }
    }
    
    return cnt==n;
}

int main()
{
    memset(h, -1, sizeof h);
    cin>>n>>m;
    while (m -- )
    {
        int a,b;
        cin>>a>>b;
        add(a, b);
        d[b]++;
    }
    
    if(topp())
    {
        for(int i=0;i<cnt;i++)
        {
            cout<<ans[i]<<" ";
        }
    }
    else cout<<"-1"<<endl;
    
    return 0;
}

最短路

dijkstra算法

朴素版的

堆优化版的

#include <iostream>
#include <cstring>
#include <algorithm>
#include<queue>
using namespace std;

const int N = 1e6 + 10;
typedef pair<int, int> PII;

int h[N], e[N], ne[N],w[N], idx;
bool st[N];
int dist[N];
int n,m,s;
void add(int a, int b, int c)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[s]=0;
     priority_queue<PII, vector<PII>, greater<PII> >heap;
    heap.push({0,s});//距离＋编号
    
    while(heap.size())
    {
        PII t=heap.top();heap.pop();
        
        int id=t.second,distance=t.first;
        if(st[id])continue;
        st[id]=true;
        
        for(int i=h[id];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[id]+w[i])
            {
                dist[j]=dist[id]+w[i];
                heap.push({dist[j],j});
            }
        }
        
    }
    
}

int main()
{
    cin>>n>>m>>s;//n个点m条边
    memset(h,-1,sizeof h);
    
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
    }
    dijkstra();
    for(int i=1;i<=n;i++)
    {
    	cout<<dist[i]<<" ";
	}
    return 0;
}

[USACO09OCT] Heat Wave G - 洛谷

无向边的dijkstra只需要在建边的时候建两次就行

add(a, b, c);
add(b, a, c);

[USACO07NOV] Cow Hurdles S - 洛谷

试一下这个题能不能用dijkstra算法（堆优化+有向边（max和min））

SPFA

关于SPFA的经典好题 - 题单 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

模板

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

const int N=1e5+10;

#define fi first
#define se second

typedef pair<int,int> PII;//到源点的距离，下标号

int h[N],e[N],w[N],ne[N],idx=0;
int dist[N];//各点到源点的距离
bool st[N];
int n,m;
void add(int a,int b,int c){
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

int spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int>q;
    q.push(1);
    st[1]=true;//已经在队列里面了
    
    while(q.size())
    {
        int t=q.front();q.pop();
        st[t]=false;//出队列了
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[t]+w[i]<dist[j])
            {
                dist[j]=dist[t]+w[i];
                if(st[j]==0)
                {
                    q.push(j);
                    st[j]=true;//已经在队列里面了
                }
            }
        }
    }
    
    if(dist[n]==0x3f3f3f3f)return 0x3f3f3f3f;
    else return dist[n];
    
}

int main(){
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int res=spfa();
    if(res==0x3f3f3f3f) puts("impossible");
    else printf("%d",res);

    return 0;
}

如果要判断是否存咋负环，可以开一个数组cnt来记录边数，如果边数>=n的话，使用容斥原理可以知道存在负环。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

const int N=1e5+10;

#define fi first
#define se second

typedef pair<int,int> PII;//到源点的距离，下标号

int h[N],e[N],w[N],ne[N],idx=0;
int dist[N],cnt[N];//各点到源点的距离,加一个cnt记录所有遍历的边数，然后用容斥原理就可以判断是否有负环了
bool st[N];
int n,m;
void add(int a,int b,int c){
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

int spfa(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    queue<int>q;
    for(int i=1;i<=n;i++)
    {
        st[i]=true;
        q.push(i);
    }
    
    while(q.size())
    {
        int t=q.front();q.pop();
        st[t]=false;//出队列了
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[t]+w[i]<dist[j])
            {
                dist[j]=dist[t]+w[i];
                cnt[j]=cnt[t]+1;
        
                if(cnt[j]>n)return true;
                if(st[j]==0)
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    
    return false;
    
}

int main(){
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int res=spfa();
    if(res==1) puts("Yes");
    else printf("No");

    return 0;
}

Floyd

Floyd - 题单 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 210, INF = 1e9;

int n, m, Q;
int d[N][N];

void floyd()
{
    for (int k = 1; k <= n; k ++ )//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]);// i j = i k k j
}

int main()
{
    scanf("%d%d%d", &n, &m, &Q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);//有向图
    }
    floyd();
    while (Q -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);

        int t = d[a][b];
        if (t > INF / 2) puts("impossible");
        else printf("%d\n", t);
    }

    return 0;
}

P2888 [USACO07NOV] Cow Hurdles S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

这个题，稍微变了一下这个方程：d[i][j]=min(d[i][j],max(d[i][k],d[k][j]));

#include<bits/stdc++.h>
using namespace std;
const int N=310,INF=0x3f3f3f3f;
int n,m,T;
int d[N][N]; 
void floyd()
{
	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],max(d[i][k],d[k][j]));
			}
		}
	}
}

int main()
{
	cin>>n>>m>>T;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(i==j)d[i][j]=0;
			else d[i][j]=INF;
	
	while(m--)
	{
		int a,b,w;
		cin>>a>>b>>w;
		d[a][b]=min(d[a][b],w);
	}
	floyd();
	while(T--)
	{
		int a,b;
		cin>>a>>b;
		int dis=d[a][b];
		if(dis>INF/2)cout<<"-1"<<endl;
		else cout<<dis<<endl;
	}
	
	return 0;
}

 然后我发现23年蓝桥杯有一道题可以用Floyd的这个例题相同的思路来骗分（无向图，建边的时候建两次就行）

[蓝桥杯 2023 省 A] 网络稳定性 - 洛谷

看到题解里面说的：P3379 最近公共祖先【黄】+P3366 最小生成树【橙】=P9235 网络稳定性【蓝】，但是我还没学最近公共祖先

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, INF = 1e9;

int n, m, Q;
int d[N][N];

void floyd()
{
    for (int k = 1; k <= n; k ++ )//k要放在最外层
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = max(d[i][j], min(d[i][k],d[k][j]));// i j = i k k j
}

int main()
{
    scanf("%d%d%d", &n, &m, &Q);
	//初始化 
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
           d[i][j] = -1;

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = max(d[a][b], c);
        d[b][a] = max(d[b][a], c);//无向 
    }
    floyd();
    while (Q -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);

        int t = d[a][b];
        printf("%d\n", t);
    }

    return 0;
}

最小生成树

最小生成树算法及例题整理_求解最小生成树-CSDN博客

prim朴素版算法的模版

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510,INF=0x3f3f3f3f;
int n,m;
int g[N][N];
int dist[N];
bool st[N];
int prim()
{
    memset(dist,0x3f,sizeof dist);
    
    int res=0;
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            //没有进入集合+距离比较小，更新
            if(!st[j]&&(t==-1||dist[j]<dist[t]))t=j;
        }
        
        //如果不连通，这个需要记一下，
        if(i&&dist[t]==INF)return INF;
        
        if(i)res+=dist[t];
        st[t]=true;
        
        for(int j=1;j<=n;j++)
        {
            dist[j]=min(dist[j],g[t][j]);//和最短路的区别就只是在这里
            //求解到集合的最短距离
        }
        
    }
    return res;
}


int main()
{
    scanf("%d%d", &n, &m);

    memset(g, 0x3f, sizeof g);

    while (m -- ){
        int a,b,c;
        scanf("%d%d%d", &a, &b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }

    int t = prim();

    if (t == INF) puts("impossible");
    else printf("%d\n", t);

    return 0;
}

 Kruskal算法

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010, M = 200010, INF = 0x3f3f3f3f;
int n, m;
int p[N];

struct Edge
{
    int a,b,w;
    bool operator <(const Edge &W)const
    {
        return w<W.w;
    }
}edges[M];

int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges,edges+m);
    for(int i=1;i<=n;i++)p[i]=i;
    
    int res=0;//记录权重之和
    int cnt=0;//记录边数
    
    for(int i=0;i<m;i++)
    {
        int a=edges[i].a,b=edges[i].b,w=edges[i].w;
        a=find(a),b=find(b);
        if(a!=b)//使用并查集进行查询
        {
            p[a]=b;
            res+=w;
            cnt++;
        }
    }
    
    if(cnt<n-1)return INF;
    else return res;
   
}



// int kruskal()
// {
//     sort(edges,edges+m);
    
//     for(int i=1;i<=n;i++)p[i]=i;
    
//     int res=0,cnt=0;
//     for(int i=0;i<m;i++)
//     {
//         int a=edges[i].a,b=edges[i].b,w=edges[i].w;
        
//         a=find(a),b=find(b);
//         if(a!=b)
//         {
//             p[a]=b;//合并
//             res+=w;
//             cnt++;
//         }
//     }
//     if(cnt<n-1)return INF;
//     return res;
// }


int main()
{
    scanf("%d%d", &n, &m);

    for (int i = 0; i < m; i ++ )
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }

    int t = kruskal();

    if (t == INF) puts("impossible");
    else printf("%d\n", t);
    
    return 0;
}

最近公共祖先

OYYHXPJR
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 图论算法实现工具——NetworkX1
08-03
1.前言前段时间和几位小伙伴一起学习数学建模，其中解决拼接碎纸片问题（2013年全国大学生数学建模B题1）时候使用了图的模型，虽然Matlab解决具体的图论问题
七桥问题c语言程序数据结构,数据结构与算法学习——图论
weixin_33575588的博客
05-18 673
什么是图？在计算机程序设计中，图结构也是一种非常常见的数据结构但是图论其实是一个非常大的话题图结构是一种与树结构有些相似的数据结构图论是数学的一个分支，并且在数学概念上，树是图的一种它以图为研究对象，研究顶点和边组成的图形的数学理论和方法主要研究的目的是事务之间的关系，定点代表事务，边代表两个事物间的关系图的现实案例人与人之间的关系网甚至科学家们在观察人与人之间的关系网时，还发现了六度空间理论六度...
Tarjan 算法——图论学习笔记
pyy_official的博客
01-10 2239
Tarjan 算法在图论问题中有大用，特别是有关联通性的题。写字不易，给个赞吧~
C++学习笔记——图论
z0816208的博客
04-05 1043
图是由组成的，把图记作二元组G=（v，e）
数模常用算法——图论算法简介&代码实现
JiandaoStudio
06-19 9860
图与网络优化概述 目录 1. 求 两个指定顶点之间的最短路径（Dijkstra算法） 2. 求每对顶点之间的最短距离（Floyd算法） 3.最小代价生成树 3.1 prim算法模板，当前测试点下标从0开始，输出从1开始： 3.2 kruskal算法模板： 4. 网络流 4.1最大流算法（最简单的EK算法） 4.2 二分最大权匹配 KM算法模板 4.3 最小...
数学建模——图论学习
Scbgv的博客
05-08 1396
图论的基础知识点学习
算法——图论：拓扑排序
lyx200154的博客
03-29 398
你这个学期必须选修numCourses门课程，记为0到。在选修某些课程之前需要一些先修课程。先修课程按数组给出，其中，表示如果要学习课程ai则先学习课程bi。[0, 1]01请你判断是否可能完成所有课程的学习？如果可以，返回true；否则，返回false。即图中不能有环。
21级数据结构与算法实验6——图论
m0_63485942的博客
11-09 3173
7-1 邻接矩阵表示法创建无向图作者 王东单位 贵州师范学院采用邻接矩阵表示法创建无向图G ，依次输出各顶点的度。输入格式:输入第一行中给出2个整数i(0
数学建模算法——图论最短路径求解：迪杰斯特拉、贝尔曼福特、弗洛伊德（自用）
m0_52136111的博客
04-21 1056
数学建模算法——图论最短路劲求解：迪杰斯特拉算法、贝尔曼福特算法、弗洛伊德算法
数学——七桥问题——图论
小天狼星_布莱克 的博客
08-24 2443
当涉及数学，有很多不同的话题可以讨论。你是否有特定的数学领域、概念或问题想要了解更多？： 包括代数方程、多项式、群论、环论等。： 从欧几里得几何到非欧几何，涉及空间、形状、位置等。： 研究变化率和积分，是分析学的基础。： 研究随机事件的概率和数据的分析。： 研究整数的性质，包括素数、同余、数的分解等。： 研究向量、矩阵、线性方程组等。： 研究包含导数的方程，用于建模自然现象。： 探讨命题、证明、集合的性质等。： 包括图论、组合数学、逻辑等离散结构的研究。： 数学在科学、工程、经济等领域的应用。
数学建模——图论
lmx1458070445的博客
08-22 682
图论学习小结适用对象基本理论经典算法 适用对象 图论是为了解决包含二元关系的离散系统所提出的数学模型，并可对该模型进行求解。 基本问题： 最短路问题 最大流问题 最小费用流问题 匹配问题 基本理论 无向图 有向图 元素 无序对集合G=(V,E)G=(V,E)G=(V,E)顶点集&边集 有序对集合G=(V,A)G=(V,A)G=(V,A)顶点集&弧集 顶点数：∣V∣|V|∣V∣ \qquad 边数：∣E∣|E|∣E∣ 经典算法 ...
【1.数据结构和算法学习目录】
01-07
本专栏记录研究生期间算法学习过程，从基础回顾到算法落地。算法学习范围为蓝桥杯官网提供的命题范围： 计算机算法：枚举、排序、搜索、计数、贪心、动态规划、图论、数论、博弈论*、概率论*、计算几何*、字符串算法...
算法和数据结构——左程云.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
图论基础_C++_学习_C++图论_图论方法c++_
10-02
c++入门——图论基础，带标程，带习题，赶紧下载吧
数据结构&算法——Java.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独
WIIIter的博客
05-08 249
【代码】算法训练Day26 | 332.重新安排行程 ● 51. N皇后 ● 37. 解数独。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 367
【代码】：1080：余数相同问题
找第二大的数（分治法）
最新发布
2201_75525567的博客
05-11 296
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
从零学算法6
m0_53256503的博客
05-11 972
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。输入：s = “PAYPALISHIRING”, numRows = 3。输入：s = “PAYPALISHIRING”, numRows = 4。输入：s = “A”, numRows = 1。输出：“PAHNAPLSIIGYIR”输出：“PINALSIGYAHRPI”
图论算法实现matlab
08-18
- *1* [【老生谈算法】matlab实现图论程序算法大全——图论程序算法大全](https://blog.csdn.net/m0_53407570/article/details/126208789)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值