基础图论算法

最新推荐文章于 2022-04-25 07:54:45 发布
最新推荐文章于 2022-04-25 07:54:45 发布
阅读量508 收藏 1
点赞数
文章标签： c++ 算法 acm竞赛 图论 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50961321/article/details/123664067
版权

        图论知识是算法当中的一个非常重要的模块，同时也可以算是对算法的学习正式进入入门的阶段。有关于图论的基础知识在这里就不做过多的介绍了，这一部分的知识详见树与二叉树和图这两篇以数据结构为基础的文章。本篇博客的题目来源全部来源于团体程序设计天梯赛-练习集中，主要是以模板为主，为今后做题做好准备。

Part 1 并查集

        并查集可以算是图上的最常见的搜索算法，通俗来讲，并查集可以解决一些“溯源”的问题，比如说有关于连通图的问题，就可以拿并查集来解决。并查集的套路也非常固定，而且非常的实用。下面的题目都是基于并查集来做的（当然这些题目的解法不唯一，在这里只是展现用并查集处理问题的方法）。

//并查集模板

void init()//初始化
{
    for (int i=1;i<=n;i++)
        pre[i]=i;
}

int find(int x)//溯源
{
    return pre[x]==x?x:find(pre[x]);//这一部分也可以写成非递归的形式
}

void union(int x,int y)//合并
{
    x=find(x);
    y=find(y);
    if (x!=y)
        pre[y]=x;
}

L2-010 排座位

题目链接

         这道题是一个非常经典的并查集模型题，“朋友的朋友就是朋友”就已经得到一个信息：基于“朋友”建图，我们可以根据朋友的关系去建立这一张关系网，进而根据不同的人物关系得到相应的结果，具体代码如下：

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

int pre[105];
int g[105][105];
int n,m,q;
void init()
{
	for (int i=1;i<=n;i++)
		pre[i]=i;
}
int find(int x)
{
	return pre[x]==x?x:find(pre[x]);
}
void union(int x,int y)
{
	x=find(x);
	y=find(y);
	if (x!=y)
		pre[y]=x;
}

int main()
{
    cin>>n>>m>>q;
    init();
    while (m--)
    {
    	int a,b,f;
    	cin>>a>>b>>f;
    	g[a][b]=g[b][a]=f;
    	if (f==1)
    		union(a,b);
	}
	int x1,y1;
	while (q--)
	{
		int x,y;
		cin>>x>>y;
		x1=find(x);
		y1=find(y);
		if (g[x][y]!=-1&&x1==y1)
			cout<<"No problem"<<endl;
		else if (g[x][y]==0)
			cout<<"OK"<<endl;
		else if (g[x][y]==-1&&x1==y1)
			cout<<"OK but..."<<endl;
		else if (g[x][y]==-1&&x1!=y1)
			cout<<"No way"<<endl;
	}
    return 0;
}

        类似有关并查集的题目还有L2-013 红色警报、L2-024 部落等。

Part 2 树上的操作

        树的操作相信大家有了数据结构的基础后应该有所了解了，但实际上我们在写代码的时候，其实是不会采用数据结构中的那种写法，而是用一种更加直观的方式去建树，并且去访问树中的节点（四种遍历）。

//建立一棵二叉树

struct node
{
    int data;
    node *l, *r;
};

int N, pre[maxn], in[maxn], post[maxn];//存储节点数组

node* create(int postL,int postR,int inL,int inR)
{
    if(postL>postR)
        return NULL;

    node* root=new node;
    root->data=post[postR];//先序这里等式右端为pre[preL]
    int k;
    for (k=inL;k<=inR;k++)
        if (in[k]==post[postR])
            break;
    int numLeft=k-inL;
    root->l=create(postL,postL+numLeft-1,inL,k-1);
    root->r=create(postL+numLeft,postR-1,k+1,inR);
    return root;
}
//层次遍历二叉树

void Bfs(node* root)
{
    queue<node*> q;
    q.push(root);
    while(!q.empty())
    {
        node* cur=q.front();
        q.pop();
        cout<<cur->data<<" ";

        if(cur->l!=NULL)
            q.push(cur->l);
        if(cur->r!=NULL)
            q.push(cur->r);
    }
}

L2-006 树的遍历

题目链接

        建树相信大家都不陌生，这里建树的过程和上面的代码一致，采用数组存储相应的顺序，最后按照一定的递归规则进行建树，层次遍历时采用BFS思想，利用一个队列进行存储，具体代码如下：

#include <bits/stdc++.h>
using namespace std;
const int maxn=35;
struct node
{
    int data;
    node *l, *r;
};

int N, pre[maxn], in[maxn], post[maxn];//存储节点数组

node* create(int postL,int postR,int inL,int inR)
{
    if(postL>postR)
        return NULL;

    node* root=new node;
    root->data=post[postR];
    int k;
    for (k=inL;k<=inR;k++)
        if (in[k]==post[postR])
            break;
    int numLeft=k-inL;
    root->l=create(postL,postL+numLeft-1,inL,k-1);
    root->r=create(postL+numLeft,postR-1,k+1,inR);
    return root;
}
int indx = 1;
void Bfs(node* root)
{
    queue<node*> q;
    q.push(root);
    while (!q.empty())
    {
        node* cur=q.front();
        q.pop();
        if (indx++!=1)
            cout<<' '<<cur->data;
        else
            cout<<cur->data;

        if(cur->l!=NULL)
            q.push(cur->l);
        if(cur->r!=NULL)
            q.push(cur->r);
    }
}
int main()
{
    cin>>N;
    for (int i=0;i<N;i++)
        cin>>post[i];
    for (int i=0;i<N;i++)
        cin>>in[i];

    node* root=create(0,N-1,0,N-1);
    Bfs(root);

	return 0;
}

        类似的题目还有L2-004 这是二叉搜索树吗？ 、L2-011 玩转二叉树等。

Part 3 最短路径Dijkstra

        迪杰斯特拉算法是求最短路径中最常用的一种算法，具体该算法的推理过程在这里就不详细说明了，不同于数据结构中的写法，在这里采用了一种比较简洁的形式。

void dijkstra()
{
    memset(vis,0,sizeof(vis));
    for (int i=0;i<n;i++)
		dist[i]=G[s][i];
    int Min=inf;
    int v=-1;
    for (int i=0;i<n;i++)
    {
        Min=inf;
        v=-1;
        for (int j=0;j<n;j++)
        {
            if (!vis[j]&&dist[j]<Min)
            {
                Min=dist[j];
                v=j;
            }
        }
        vis[v]=1;
        for (int j=0;j<n;j++)
        {
            if(!vis[j]&&dist[j]>dist[v]+G[v][j])
                dist[j]=dist[v]+G[v][j];
        }
    }
}

L2-001 紧急救援

题目链接

        这是一道非常经典的最短路径算法问题，本题还要求输出路径，所以最后还要用DFS进行深度优先搜索，将答案记录在容器中一并输出。具体代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 550;
int n,m,s,d,Maxv,cnt;
int val[maxn],vis[maxn],dist[maxn];
int G[maxn][maxn];
vector<int> ans,pre;
void dijkstra()
{
    memset(vis,0,sizeof(vis));
    for (int i=0;i<n;i++)
		dist[i]=G[s][i];
    int Min=inf;
    int v=-1;
    for (int i=0;i<n;i++)
    {
        Min=inf;
        v=-1;
        for (int j=0;j<n;j++)
        {
            if (!vis[j]&&dist[j]<Min)
            {
                Min=dist[j];
                v=j;
            }
        }
        vis[v]=1;
        for (int j=0;j<n;j++)
        {
            if(!vis[j]&&dist[j]>dist[v]+G[v][j])
                dist[j]=dist[v]+G[v][j];
        }
    }
}
void dfs(int x, int w)
{
    if(x == d)
    {
        if (w>Maxv)
        {
            Maxv=w;
            ans=pre;
        }
        cnt++;
        return;
    }
    for (int i=0;i<n;i++)
    {
        if(G[x][i]&&!vis[i]&&dist[i]==dist[x]+G[x][i])
        {
            vis[i]=1;
            pre.push_back(i);
            dfs(i,w+val[i]);
            pre.pop_back();
            vis[i]=0;
        }
    }
}
int main()
{
    int u,v,w;
    cin>>n>>m>>s>>d;
    for (int i=0;i<n;i++)
    	cin>>val[i];
    for (int i=0;i<n;i++)
    {
        for (int j=0;j<n;j++)
        {
            if (i!=j)
				G[i][j] = inf;
            else
				G[i][j] = 0;
        }
    }
    for (int i=0;i<m;i++)
    {
        cin>>u>>v>>w;
        G[u][v]=w;
        G[v][u]=w;
    }
    dijkstra();
    Maxv=0;
    cnt=0;
    memset(vis,0,sizeof(vis));
    pre.push_back(s);
    dfs(s,val[s]);
    cout<<cnt<<" "<<Maxv<<endl;
    int len=ans.size();
    for (int i=0;i<len;i++)
    {
        if (i==0)
			cout<<ans[i];
        else
        	cout<<" "<<ans[i];
    }
    return 0;
}

Part 4 DFS与BFS

        DFS与BFS都是图上非常重要的搜索算法，其中DFS应用较广泛，在基础的算法题目中经常见到（其实是本菜鸟确实不大会BFS），其基本的思想是回溯法，根据不同的题目，不同的要求去写相应的DFS函数，这里给出一个非常基础的DFS模板：

L2-020 功夫传人

题目链接

 

        这道题其实并没有利用到回溯思想，但确实是一道非常好的dfs裸题，每次递归的参数都有所变化，利用了一个二维vector记录变量，具体代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,k,x,vis[100010];
double sum,z,r;
vector<vector<int>>v;
void dfs(int index,double power)
{
	if(vis[index])
	{
		sum+=power*v[index][0];
		return ;
	}
	for(int i=0;i<v[index].size();i++)
		dfs(v[index][i],power*(1-r/100));
}
int main()
{
	cin>>n>>z>>r;
	v.resize(n);
	for(int i=0;i<n;i++)
	{
		cin>>k;
		if(!k)
		{
			cin>>x;
			vis[i]=1;
			v[i].push_back(x);
		}
		while(k--)
		{
			cin>>x;
			v[i].push_back(x);
		}
	}
	dfs(0,z);
	cout<<(int)sum;
}

 L2-038 病毒溯源

题目链接

         光看标题就知道这是一个深度优先搜索的题目，在众多输入中找到一条最长的变异链。所以很明显，有关DFS算法的题目基本上都是要求最长的…、或者输出某一条路径等等这类关键字。和第一部分说明的并查集类似，并查集是一个建图的过程，这个是一个遍历的过程，所以如果发现这二者结合起来的时候也不必惊讶。具体代码如下：

#include<bits/stdc++.h>
#include<algorithm>
#include<iostream>
#include<set>
#include<stack>
#include<string>
#include<queue>
#include<vector>
#include<cctype>
#include<map>
using namespace std;
int n;
const int maxn=10001;
vector<int>v[maxn];
vector<int>temp;
int t[maxn];
void Dfs(int index,vector<int>&p){//这里需要用到&p，否则会内存过大
	if(p.size()>temp.size()){//找到更深的，更新temp数组
		temp.clear();
		temp=p;
	}
	for(int i=0;i<v[index].size();i++){//标号为index的孩子节点
		p.push_back(v[index][i]);//先将孩子节点入p
		Dfs(v[index][i],p);//深搜孩子节点
		p.pop_back(); //记得回溯！！
	}
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		int k;
		cin>>k;
		while(k--){//当k等于0 时，不执行循环，所以不需要特殊考虑
			int x;
			cin>>x;
			v[i].push_back(x);
			t[x]=1;//将所有的孩子节点的t都设为1，这样只需要找到不是1的节点，那个节点就是根节点！
		}
		if(v[i].size()){
			sort(v[i].begin(),v[i].end());//每次放完孩子都需要排序，以求得最小的编号
		}
	}
	for(int i=0;i<n;i++){
		if(!t[i]){//这一步的目的是找到根节点进行深搜，
			vector<int>p;
			p.push_back(i);
			Dfs(i,p);//从根节点开始搜索，每次更新数组p
			break;
		}
	}
	cout<<temp.size()<<endl;
	for(int i=0;i<temp.size();i++){
		if(!i) cout<<temp[i];
		else cout<<" "<<temp[i];
	}
}

BrilliantWilliam
关注
基本图论算法--《算法导论》
taotao 的大学墓志
08-23 7070
广度优先搜索（BFS）算法描述对于一个给定的图G(V,E)G (V,E) 和一个源节点SS BFS能遍历所有从SS出发能到达的节点，并计算SS 能到达每一个节点的距离（最少的边数），并生成一可广度优先搜索树。代码说明u.pu.p uu的前驱结点 u.du.d uu到SS的距离 u.coloru.color uu的状态，WHITE 未被搜索到，GRAY正在被发现，BLACK以搜索结束 QQ 队列
图论之常用算法
最新发布
风间琉璃的博客
07-28 681
介绍图论中常用的相关算法
【NOIp复习】图论基础算法
weixin_30553065的博客
11-06 213
图 有向图的拓扑排序（用来判环） 定义 将有向图中的顶点以线性方式进行排序。即对于任何连接自顶点u到顶点v的有向边uv，在最后的排序结果中，顶点u总是在顶点v的前面。 存在条件 如果存在环，那么就不可能满足u->v时u总是在v的前面了。所以必须是有向五环图（DAG）才能拓扑排序。 是否唯一 如果该DAG任意两个顶点都有确定的关系，拓扑排序就是唯一...
图论算法基础
Java搜索工程技术栈
04-25 208
经常有读者问我「图」这种数据结构，其实我在学习数据结构和算法的框架思维中说过，虽然图可以玩出更多的算法，解决更复杂的问题，但本质上图可以认为是多叉树的延伸。 面试笔试很少出现图相关的问题，就算有，大多也是简单的遍历问题，基本上可以完全照搬多叉树的遍历。 那么，本文依然秉持我们号的风格，只讲「图」最实用的，离我们最近的部分，让你心里对图有个直观的认识，文末我给出了其他经典图论算法，理解本文后应该都可以拿下的。 图的逻辑结构和具体实现 一幅图是由节点和边构成的，逻辑结构如下： 什么叫「逻辑结构..
图论基础算法
csdnwqy030429的博客
01-23 3323
图论基础问题图的存储与遍历拓扑排序最短路算法最小生成树二分图 图的存储与遍历 拓扑排序 最短路算法 最小生成树 二分图
算法：图论基础
OceanStar的博客
01-13 462
图 定义 图(graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)G(V, E)G(V,E)，其中，G表示一个图，V表示图G中顶点的集合，E是图G中边的集合。 如下中，共有 V0，V1，V2，V3 这 4 个顶点，4 个顶点之间共有 5 条边。 注： 当线性表中没有数据节点时，线性表为空表 书中没有节点是，树为空树 但是，在图中不允许没有顶点，但是可以没有边 无向边 如果顶点x和y之间的边没有方向，则称该边为无向边（x, y），（x，y）与（y，x）意义相同，表示x和y之
tulunsuanfa.rar_图论_图论算法_图论算法实现_算法
09-20
接下来，我们将探讨一些**基础图论算法**： 1. **深度优先搜索（DFS）**：从一个顶点出发，尽可能深地探索图的分支，直到访问所有可达顶点。在回溯过程中，标记已访问的顶点，避免重复访问。 2. **广度优先搜索...
图论算法理论实现_图论及其_图论算法_图论_图论知识_
09-30
图论是数学的一个分支，主要研究点（顶点）与线（边）组成的结构，它在计算机科学中有着广泛的应用，特别是在...《图论算法理论实现及其应用》这本书无疑是一份宝贵的资源，它将帮助读者深入理解这一领域的核心内容。
图论算法及其MATLAB实现（完整版）
04-30
《图论算法及其MATLAB实现》是一本深入探讨图论算法与其实现的书籍，尤其强调了使用MATLAB这一强大的科学计算工具进行编程实践。图论是计算机科学和数学的一个重要分支，它研究的是点（节点）和点之间的连接线（边）...
图论算法软件图论算法软件
06-02
图论算法软件是一种用于解决与图相关问题的计算工具，它涵盖了广泛的数学和计算机科学理论。在图论中，一个图是由节点（或顶点）和连接这些节点的边构成的抽象结构。这个领域的算法在计算机科学中有着广泛应用，如...
数学建模算法培训 图论算法及其MATLAB程序代码 共12页.pdf
03-06
"数学建模算法培训 图论算法及其MATLAB程序代码" 本资源主要介绍了图论算法在数学建模中的应用，具体来说是 Warshall...本资源为读者提供了图论算法的基础知识和 MATLAB 程序代码，帮助读者更好地理解和应用图论算法。
图论算法的基础知识
连峰碧波间，浅水泛舟游
06-05 3175
图的表示\large\textbf{图的表示} \quad\quad如果有向图是稠密的，也就是图中的边数|E||E|和定点数|V||V|满足如下关系|E|=O(|V|2)|E|=O(|V|^2)。那么我们就用二维数组来表示，如果有向图是稀疏的，也就是边数相当的少，那么我们就用邻接表来表示。它就是一个结构体数组，每个元素表示一个顶点，然后指向它的所有相邻的顶点（这个相邻是指出边）。 \quad\q
图论算法
weixin_33716154的博客
06-25 426
Problem1一笔画问题 题目描述 给出一个图，求其欧拉回路（若没有回路，则求其欧拉路径），若不存在则输出‘No solution’ 输入 输入的第一行为边数F(<=1024)，后面F行每行表示一条边（定点标号范围为1-500） 输出 输出一条合法的欧拉回路（路径），若有多条满足要求，输出其字典序最小的那一个。 Problem2 Car的旅行路线 题目描...
图论（基本的图算法）
dzy521的博客
04-04 1926
一、图的表示 对于图G=(V,E)，可以用两种标准表示方法表示，一种表示法将图作为邻接链表的组合，另一种表示法则将图作为邻接矩阵来看待。 邻接矩阵：将两点是否可以到达（到达所需费用）存在一个二维数组中 特点：快速访问两点间是否有有边向连；占用内存大，通常用于稠密图（边数接近顶点树平方）中 邻接链表：用链表存与第i个顶点相连的数字，通常使用vec数组或者链式前向星 优点：内存小；无法快速判断是否有边，常用于稀疏图 二、广度优先搜索 三、深度优先搜索 ...
图论基础和图论算法
洛谷棕名用户的博客（兔子的博客）
06-09 975
图论基础 图的基础知识 图论的基本研究对象，图由节点和边组成。 节点 图二、图二中黑色的圆圈就是节点，表示某个事物或对象。 边 图二、图二中顶点之间灰色的线条就是边，表示事物与事物之间的关系。 权值 权值，即每条边都有与之对应的值。例如当顶点代表某些物理地点时，两个顶点间边的权重可以设置为路网中的开车距离（例如：从北京到上海的铁路1300km，从上海到重庆的铁路1600km，这里就是分别把北京、...
图论算法基础讲解
"图论算法入门，适合初学者的图论算法教程，由孙云龙主讲，内容涵盖数值计算...图论算法入门课程将引导初学者逐步理解图的理论基础，熟悉图的表示方法，并掌握利用图论解决实际问题的技能，是进入这个领域的良好起点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值