图论模板自存c++

原创 已于 2025-11-14 12:23:54 修改 · 99 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图论 #c++ #算法

于 2025-11-14 12:08:50 首次发布

树的重心/深搜
图中点的层次/宽搜
有向图的拓扑排序
Dijkstra求最短路
bellman-ford
spfa求最短路
spfa判负环
floyd求最短路
prim求最小生成树
kruskal求最小生成树
判定二分图
匈牙利算法/二分图的最大匹配

树的重心/深搜

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;

struct node{
    int to,next;
}edge[N*2];
int head[2*N];
int cnt;
bool vis[N];

void add(int u,int v)
{
    edge[++cnt] = {v,head[u]};
    head[u] = cnt;
}
int ans= N;
int dfs(int u)
{
    int res = 0,sum = 1;
    vis[u] = 1;
    
    for(int i = head[u];i;i=edge[i].next)
    {
        int to = edge[i].to;
        if(vis[to] == 0)
        {
            int s = dfs(to);
            res = max(res, s);
            sum += s;
        }
        
    }
    res = max(res , n - sum);
    ans = min(ans, res);
    
    return sum;
}

int main()
{
    cin>>n;
    for(int i = 1;i < n;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u , v);
        add(v , u);
    }
    dfs(1);
    cout<<ans<<"\n";
    
    return 0;
}

图中点的层次/宽搜

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5+5;
struct node{
    int to,next;
}edge[N];
int head[N];
int cnt;
int n,m;
int dist[N];
bool vis[N];

void add(int u,int v)
{
    edge[++cnt]={v,head[u]};
    head[u] = cnt;
}

priority_queue<pair<int,int> > q;

int dfs()
{
    memset(dist,0x3f,sizeof dist);
    q.push({0,1});
    dist[1] = 0;
    while(!q.empty())
    {
        int now = q.top().second;
        q.pop();
        if(vis[now] == 1) continue;
        vis[now] = 1;
        if(now == n)
        {
            return dist[now];
        }
        for(int i = head[now];i;i=edge[i].next)
        {
            int to=edge[i].to;
            if(dist[to] > dist[now] + 1)
            {
                dist[to] = dist[now] + 1;
                q.push({-1*dist[to],to});
            }
        }
    }
    
    return -1;
}

int main()
{
    cin>>n>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u,v);
    }
    
    cout<<dfs();
    
    return 0;
}

有向图的拓扑序列

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
int m,n;
vector<int>e[N],tp;
int d[N];

queue<int>q;

int toposort()
{
    for(int i = 1;i <= n;i++)
        if(d[i] == 0) q.push(i);
    
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        tp.push_back(now);
        for(auto i : e[now])
        {
            if(--d[i] == 0) q.push(i);
        }
    }
    return (tp.size() == n);
    
}


int main()
{
    cin>>n>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v;
        cin>>u>>v;
        d[v]++;
        e[u].push_back(v);
    }
    bool f = toposort();
    if(f == 0) cout<<-1<<"\n";
    else
    {
        for(auto i : tp)
        {
            cout<<i<<" ";
        }
    }
    
    return 0;
}

Dijkstra求最短路

#include <bits/stdc++.h>
using namespace std;
const int N = 150005;
int n,m;
struct node{
    int to,w,next;
}edge[N];
int head[N];
int cnt;

void add(int u,int v,int w)
{
    edge[++cnt] = {v,w,head[u]};
    head[u] = cnt;
}
int dist[N];
bool vis[N];
priority_queue<pair<int ,int > > q;

void dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    q.push({0,1});
    dist[1] = 0;
    
    while(!q.empty())
    {
        int now = q.top().second;
        q.pop();
        if(vis[now] == 1) continue;
        vis[now] = 1;
        for(int i = head[now];i;i=edge[i].next)
        {
            int to = edge[i].to;
            int w = edge[i].w;
            if(dist[to] > dist[now] + w)
            {
                dist[to] = dist[now] + w;
                q.push({-1*dist[to],to});
            }
        }
    }
    if(dist[n] >= 0x3f3f3f3f) cout<<"-1"<<"\n";
    else cout<<dist[n]<<"\n";
    return;
    
}

int main()
{
    cin>>n>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    dijkstra();
    
    return 0;
}

bellman-ford

#include <bits/stdc++.h>
using namespace std;

struct node{
    int u,v,w;
}edge[10005];
int n,m,k;
int dist[505];
int dist2[505];
void bellman()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i = 0;i < k;i++)
    {
        memcpy(dist2,dist,sizeof dist);
        for(int j = 1;j <= m;j++)
        {
            int u = edge[j].u;
            int v = edge[j].v;
            int w = edge[j].w;
            dist[v] = min(dist2[u]+w,dist[v]);
            
        }
    }
    
    if(dist[n] >= 0x3f3f3f3f/2) cout<<"impossible"<<"\n";
    else cout<<dist[n]<<"\n";
}

int main()
{
    cin>>n>>m>>k;
    for(int i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        edge[i] = {u,v,w};
    }
    bellman();
    
    return 0;
}

spfa求最短路

#include <bits/stdc++.h>
using namespace std;

struct node{
    int u,v,w;
}edge[10005];
int n,m,k;
int dist[505];
int dist2[505];
void bellman()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i = 0;i < k;i++)
    {
        memcpy(dist2,dist,sizeof dist);
        for(int j = 1;j <= m;j++)
        {
            int u = edge[j].u;
            int v = edge[j].v;
            int w = edge[j].w;
            dist[v] = min(dist2[u]+w,dist[v]);
            
        }
    }
    
    if(dist[n] >= 0x3f3f3f3f/2) cout<<"impossible"<<"\n";
    else cout<<dist[n]<<"\n";
}

int main()
{
    cin>>n>>m>>k;
    for(int i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        edge[i] = {u,v,w};
    }
    bellman();
    
    return 0;
}

spfa判负环

#include <bits/stdc++.h>
using namespace std;
const int N = 2005,M = 1e5+5;
int n,m;
struct node{
    int to,next,w;
}edge[M];
int head[M];
int cnt = 0;
void add(int u,int v,int w)
{
    edge[++cnt] = {v, head[u],w};
    head[u] = cnt;
}
queue<int>q;
bool vis[N];
int dist[N];
int sum[N];
bool spfa()
{

    for(int i = 1;i <= n;i++)
    {
        q.push(i);
        vis[i] = 1;
    }
    
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        vis[now] = 0;
        for(int i = head[now];i!=-1;i=edge[i].next)
        {
            int to = edge[i].to;
            int w = edge[i].w;
            
            if(dist[to] > dist[now] + w)
            {
                dist[to] = dist[now] + w;
                sum[to] = sum[now] + 1;
                if(sum[to] >= n) return 1;
                if(vis[to] == 0)
                {
                    q.push(to);
                    vis[to] = 1;
                }
            }
        }
        
        
    }
    return 0;
}


int main()
{
    memset(head,-1,sizeof head);
    cin>>n>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    bool f = spfa();
    if(f == 0) cout<<"No"<<"\n";
    else cout<<"Yes"<<"\n";
    return 0;
}

floyd求最短路

#include <bits/stdc++.h>
using namespace std;
int n,m,k;
int d[205][205];

int main()
{
    cin>>n>>m>>k;
    memset(d,0x3f,sizeof d);
    for(int i = 1;i <= n;i++) d[i][i] = 0;
    for(int i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        d[u][v] = min(d[u][v] ,w);
    }
    
    for(int l = 1;l <= n;l++)
        for(int i = 1;i <= n;i++)
            for(int j = 1;j <= n;j++)
                d[i][j] = min(d[i][j],d[i][l]+d[l][j]);
    
    for(int i = 1;i <= k;i++)
    {
        int u,v;
        cin>>u>>v;
        if(d[u][v] >= 0x3f3f3f) cout<<"impossible"<<"\n";
        else cout<<d[u][v]<<"\n";
    }
    
    
    return 0;
}

prim求最小生成树

#include <bits/stdc++.h>
using namespace std;

const int N = 505;
int g[N][N], dt[N], st[N];
int n,m;

void prim()
{
	memset(dt, 0x3f, sizeof dt);
	int res = 0;
	dt[1] = 0;
	for(int i = 0; i < n;i++)
	{
		int t = -1;
		for(int j = 1; j <= n;j++)
			if(st[j] == 0 && (t == -1 || dt[j]< dt[t])) t = j;
		if(dt[t] == 0x3f3f3f3f) 
		{
			cout<<"impossible"<<"\n";
			return;	
		}
		st[t] = 1;
		res += dt[t];
		for(int i = 1; i <= n;i++)
			if(dt[i] > g[t][i] && st[i] == 0)	
				dt[i] = g[t][i];
	}
	cout<<res<<"\n";
	
	
}

int main()
{
	memset(g , 0x3f,sizeof g);
	cin>>n>>m;
	for(int i = 1; i <= m;i++)
	{
		int u,v,w;
		cin>>u>>v>>w;
		g[u][v] = g[v][u] = min(g[u][v] , w);
	}
	prim();
	
	return 0;
}

kruskal求最小生成树

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
int n,m;
struct node{
    int u,v,w;
}e[N];
int f[N];

bool cmp(node a1,node a2)
{
    return a1.w < a2.w;
}

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

void kruskal()
{
    int ans = 0,sum = 1;
    for(int i = 1;i <= m;i++)
    {
        int u = e[i].u;
        int v = e[i].v;
        int w = e[i].w;
        
        int uu = find(u);
        int vv = find(v);
        
        if(uu != vv)
        {
            f[uu] = vv;
            ans+=w;
            sum++;
        }
    }
    if(sum < n) 
    {
        cout<<"impossible"<<"\n";
        return;
    }
    cout<<ans<<"\n";
    return;
}

int main()
{
    cin>>n>>m;
    for(int i = 1;i <= n;i++) f[i] = i;
    for(int  i = 1;i <= m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        e[i] = {u,v,w};
    }
    sort(e+1,e+m+1,cmp);
    kruskal();
    
    
    return 0;
}

判定二分图（染色法）

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
int n,m;

struct node{
    int to,next;
}edge[2*N];
int head[2*N];
int cnt;
int color[N];

void add(int u,int v)
{
    edge[++cnt] = {v,head[u]};
    head[u]=cnt;
}

bool dfs(int u,int col)
{
    color[u] = col;
    
    for(int i = head[u];i;i=edge[i].next)
    {
        int to = edge[i].to;
        if(color[to] == 0)
        {
            if(dfs(to,3 - col) == 0) return 0;
        }
        else
        {
            if(color[to] + col != 3) return 0;
        }
        
    }
    return 1;
    
}

int main()
{
    cin>>n>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u , v);
        add(v, u);
    }
    bool f = 0;
    for(int i = 1;i <= n;i++)
    {
        if(color[i]==0)
        {
            if(dfs(i,1) == 0)
            {
                cout<<"No"<<"\n";
                f = 1;
                break;
            }
        }
    }
    if(f == 0) cout<<"Yes"<<"\n";
    return 0;
}

匈牙利算法/二分图的最大匹配

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5+5;
int n1,n2,m;
struct node{
    int to,next;
}edge[N];
int head[N];
int cnt;
bool vis[505];
int f[505];
void add(int u,int v)
{
    edge[++cnt] = {v , head[u]};
    head[u] = cnt;
}

bool find(int x)
{
    for(int i = head[x];i;i=edge[i].next)
    {
        int to = edge[i].to;
        if(vis[to] == 0)
        {
            vis[to] = 1;
            if(f[to] == 0 || find(f[to]))
            {
                f[to] = x;
                return 1;
            }
            
        }
        
    }
    return 0;
}

int main()
{
    cin>>n1>>n2>>m;
    for(int i = 1;i <= m;i++)
    {
        int u,v;
        cin>>u>>v;
        add(u , v);
    }
    int ans = 0;
    for(int i = 1;i <= n1;i++)
    {
        memset(vis,0,sizeof vis);
        if(find(i) == 1) ans++;
    }
    cout<<ans<<"\n";
    return 0;
}
qin_t
关注
【C++ 实现】图论概念，最小生成树，单/多源最短路径实现
jhao的博客
07-02 1472
图论，最小生成树算法，单/多源最短路径算法实现。 Kruskal/Prim,Dijkstra/Bellman-Ford/FloydWarshall
C++ 图论之Floyd算法求解次最短路径的感悟，一切都是脱壳后找最值而已
y6123236的专栏
12-06 1841
抛开基因的影响，学霸和学渣到底是在哪一点上有差异？学霸刷完200道题，会对题目分类，并总结出解决类型问题的通用模板，我不喜欢模板这个名词，感觉到投机的意味，或许用方法或通用表达式更高级一点。而事实上模板一词更准确。每一道题目在描述时，会套上一堆场景说词，可以说是契合真正的应用领域，或者说是出题人的故弄玄虚，弄了一些花里胡哨的迷糊你的外表，这时考核的不是专业知识，而是语文阅读能力。一旦脱出外壳，露出来的底层需求，就是书本上最基础的知识。
图论模板详解
m0_72674633的博客
04-02 1567
图论算法模板详解
自己总结的关于图论一堆的模板
Richard_1101的博客
07-21 348
不说废话直接上 //dfs 走迷宫对应的伪代码框架如下： // 对坐标为 (x, y) 的点进行搜索 bool dfs(int x, int y) { if (x, y) 是终点 { // 找到了路径 return true; } 标记 (x, y) 已经访问 向上走到位置 (tx, ty) if (tx, ty) 合法 { if (dfs(tx, ty) == true) { // 递归调用dfs函数，将(tx, ty)作为当前状态进行搜索，下同。 return true
图论模板
Confidence的专栏
04-02 1351
注意: 所有模板都是从0开始计数,如果题目输入从1开始,需要自己处理
图论（洛谷刷题）
2301_79293429的博客
05-11 1760
P3386 【模板】二分图最大匹配 P1525 [NOIP2010 提高组] 关押罪犯 P3385 【模板】负环 P3371 【模板】单源最短路径（弱化版） SPFA Dij： P3385 【模板】负环 P5960 【模板】差分约束
【C++算法模板】图的存储-邻接矩阵
qq_63586399的博客
03-09 1124
邻接矩阵相比于上一篇博客邻接表的讲解要简单得多 1. 数据结构，如果将二维数组 g 定义为全局变量，那默认初始化应该为 0 ，如果题目中存在自环，可以做特判，memset 初始化数组 g 为 0x3f3f3f3f 表示无穷大，0 表示自环 2. 以下模板是无向图的邻接矩阵模板，如果改成有向图，和邻接表一样，不需要对称建边，比如有一条边是 (1,3)
匈牙利算法——图论（C++）
Annabel_CM的博客
10-21 1389
一、基本概念 1、匹配：在图论中，一个「匹配」是一个边的集合，其中任意两条边都没有公共顶点。 2、最大匹配：一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。 3、完美匹配：如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个完美匹配。 4、交替路：从一个未匹配点出发，依次经过非匹配边、匹配边、非匹配边…形成的路径叫交替路。 5、增广路：从一个未匹配点出发，走交替路，如果途径另一个未匹配点（出发的点不算），则这条交替 路称为增广路（agumenting path）。 6、匈牙利算法.
【C++】并查集模板及简单应用
qq_52765554的博客
12-25 495
并查集模板
算法竞赛常用模板（图论篇）
qq_46192236的博客
03-31 1548
有向无环图（DAG）相关 拓扑排序 定义： 在计算机科学领域，有向图的拓扑排序是对其顶点的一种线性排序，使得对于从顶点uuu到顶点vvv的每个有向边uvuvuv，uuu在排序中都在vvv之前。 在图论中，由一个有向无环图（DAG）的顶点组成的序列，当且仅当满足下列条件时，才能称为该图的一个拓扑排序（英语：Topological sorting）： 1.序列中包含每个顶点，且每个顶点只出现一次； 2.若A在序列中排在B的前面，则在图中不存在从B到A的路径。 实现：BFS DAG上的DP Tarjan算法求
图论中常见不变量与性质全集（带严格数学公式）
ZhiqianXia
11-30 364
C++课后习题训练记录Day38
zmzb0103的博客
11-29 320
在蓝桥云课中选择课程《16届蓝桥杯省赛无忧班（C&C++ 组）4期》，选择第一章中“竞赛常用库函数”课程7并开始练习。输入一个字符，判断其为大写还是小写，若为大写则转换为小写，若为小写则转换为大写，输出转换后的值。（3）练习心得：注意每段代码末尾的分号是否存在，如不存在则需即使补充；对此代码进行检验，检验后无报错，提交此代码，判题结果为正确100分。是否切换为英语模式；
STL和string实现
最新发布
An15294874732的博客
11-30 847
标准模板库。
C++ 实操
淡水瑜的博客
11-28 363
编译 C++ 代码需要依赖gcc/g++这类编译器程序（MinGW-w64、TDM-GCC 都是 Windows 下常用的免费 C++ 编译器）。2、插件2 ： 搜索安装 C/C++ Compile Run，插件右上方，配置settings修改对应路径。1、插件1 ：搜索安装 C/C++（Microsoft Official）3、配置环境变量 PATH，新增C:\mingw64\bin。2、解压后，放到路径 C:\mingw64。Windows 64位系统。Vscode IDE工具。
【C语言】struct结构体内存对齐和位段（超详解）
zore__的博客
11-30 1189
本文详细介绍了C语言中结构体的概念和使用方法。结构体是自定义数据类型，用于描述现实中的复杂对象，如学生信息包含姓名、年龄、成绩等不同类型数据。文章讲解了结构体的声明、定义、初始化方法，以及通过点操作符(.)和箭头操作符(->)访问结构体成员的方式。此外还介绍了结构体数组和结构体指针的使用场景，展示了如何用结构体存储和处理多个同类型数据。这些知识对理解和使用C语言中的复杂数据类型非常有帮助。
C++ -- STL【string的使用】
2301_80059080的博客
11-28 349
摘要：本文详细介绍了C++中的STL(标准模板库)及其字符串处理组件string类。首先对比了C语言字符数组和C++ string类的区别，突出string类的便捷性。然后重点讲解了string类的核心功能： 迭代器操作；多种初始化方式；容量操作；三种遍历方式(下标、迭代器、范围for)；修改操作；其他实用功能(find/substr/c_str等)。通过代码示例展示了string类的各种用法，并比较了不同操作的效率差异，为C++字符串处理提供了全面的参考。
openpnp - 汇川IS620PS2R8I-IAB-C的参数设置和调整
谢绝(无视)留言与私信
11-30 502
手头订制的openpnp设备精度太差了，在解决X轴丝杠齿隙的问题。首先解决了固定问题引起的物理齿隙问题(openpnp - 消除滚珠丝杠物理齿隙的方法此时，用openpnp标定X轴齿隙，还是有齿隙。在openpnp没有标定齿隙之前，控制X轴在顶部相机下运动，顶部相机下有钢尺做参照。发现，X轴丝杠有过冲的情况发生。如果openpnp在X轴丝杠过冲还没结束时，就拍照做比对，那就发生了由测量操作引起的所谓齿隙。这个“测量引起的齿隙”并不是真正的丝杠物理齿隙。
【C++—STL】set和map的使用
lxd050925的博客
11-27 808
本文系统介绍了C++ STL中的关联式容器set和map系列。主要内容包括：1. 对比序列式容器和关联式容器的区别，阐述关联式容器的非线性结构特点；2. 详细讲解set类的构造、迭代器、增删查操作，以及multiset与set的差异；3. 深入分析map类的使用，包括pair类型、构造遍历、增删查改，重点解析operator[]的多功能实现；4. 通过两个数组交集、环形链表检测、随机链表复制等例题展示实际应用。并提供了丰富的代码示例和多种解题思路。
二叉树（C语言，手撕）
weixin_51226647的博客
11-24 597
二叉树（C语言，手撕）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值