复试机试算法总结#10：图论

128 阅读 0 评论 85 点赞

我是靠谱客的博主矮小盼望，最近开发中收集的这篇文章主要介绍复试机试算法总结#10：图论，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1. 图的表示

1.1 邻接矩阵

用一个二维矩阵表示图的信息，其中每一个单元都表示一对顶点间的邻接关系。对于无权图，单元的值用1或0表示两点间有无边；对于带权图，单元的值表示权值。不存在的边，单元值取无穷大；有向图的表示同理。

适用于：稠密图、频繁判断特定顶点对是否相邻

1.2 邻接表

用动态分配的链表来替代静态分配的空间，依次提升效率。为每个结点建立一个单链表，保存与该结点相邻的所有结点信息。但实际上一般用vector实现，其中每个元素都是一个数组。

适用于：批量处理一个顶点所有关联边

2. 并查集

并查集的两个功能：判断任意两个元素是否属于同一个集合；按照要求合并不同的集合。

延申：可用来判断是否为连通图，或求图的连通分量

即：

查找：确定元素属于哪个集合。两个元素开始不断向上查找，直到找到它们的根结点，若根结点相同，则两个结点属于同一集合。
合并：将两个子集合合并成同一个集合。方法：将一棵树作为另一棵树的子树。

而为了防止树高度过高而退化为链表，需采用路径压缩：在查找某个特定结点的根结点时，将其与根结点之间的所有结点都直接指向根结点。此外，在合并两棵树时，总是将高度较低的树作为高度较高的树的子树。

例题：畅通工程

https://www.nowcoder.com/practice/4878e6c6a24e443aac5211d194cf3913?tpId=40&tqId=21457&tPage=1&rp=1&ru=/ta/kaoyan&qru=/ta/kaoyan/question-ranking

#include<iostream>
#include<cstdio>
using namespace std;
const int MAXN=1000;
int father[MAXN];//父亲节点
int height[MAXN];//结点高度
void Initial(int n)//初始化
{
for(int i=0;i<=n;++i)
{
father[i]=i;//结点的父亲设为自己
height[i]=0;//结点的高度为0
}
}
int Find(int x)//查找结点
{
if(x!=father[x])//路径压缩
father[x]=Find(father[x]);
return father[x];
}
void Union(int x,int y)
{
x=Find(x);//获取根结点
y=Find(y);
if(x!=y)//不在同一集合
{
//矮树成为高树的子树
if(height[x]>height[y])
father[y]=x;
else
father[x]=y;
}
return;
}
int main()
{
int n,m;
while(cin>>n)
{
if(n==0)
break;
cin>>m;
Initial(n);//初始化
while(m--)
{
int x,y;
cin>>x>>y;
Union(x,y);
}
int answer=-1;//n个独立集合间最少要修n-1条路，所以初始设为-1
for(int i=1;i<=n;++i)//寻找不在集合中的点
{
if(Find(i)==i)
answer++;
}
cout<<answer<<endl;
}
return 0;
}

2.3 连通图判断

注：连通分量的统计要在并查集操作进行之后，eg 畅通工程若需使用Kruskal算法，应该在主函数中对所有结点实施并查集操作后，再判断连通分量

方法：统计连通分量数目，等于1则连通；大于1则不连通

延申：判断所给的图是否为树——连通分量=1且各点入度最大为1且根结点数为1 或连通分量为0且根结点数为0（空树），需要新增两个数组统计入度和是否访问，eg：Is It A Tree?

int Find(int x)//与前面相同的查找根结点函数
{
if(x!=father[x])
father[x]=Find(father[x]);
return father[x];
}
int main()
{
~~~~~~~~~~~~~~~~
int component=0;//连通分量从0开始计数，而未连通的道路则从-1开始计数
for(int i=1;i<n;++i
{
if(Find(i)==i)
component++;
}
if(component==1)
连通;
else
不连通;
return 0;
}

2.2 欧拉回路

例题：欧拉回路

首先对于无向图而言，欧拉回路指的是通过所有的边有且仅有一次，然后可以回到原点的图，需要满足两个要求：

图是连通图：可以采用并查集进行判断
图中所有顶点的度数(入度+出度)均为偶数：可以采用inDegree数组进行标记

注:孤立点忽略不计(只存在单点回路的边，不不存在任何相连的边)，欧拉图只要求通过所有的边，然后能回到原点即可，因此对于孤立的点可以无需考虑，这里采用set存储非孤立的结点的编号。后续统计度数的奇偶性以及连通分量的个数时可以忽略这些孤立的顶点不管。

3. 最小生成树

3.1 Prim算法

先确定点再确定边

3.2 Kruskal算法

找最小边，顺便确定点。涉及并查集操作。步骤如下：

初始时所有顶点孤立
按边的权值递增来遍历所有边，若遍历到的某个边的两个顶点属于不同集合（Find(该边的一段)!=Find(该边的另一端)），则该边为最小生成树的边，并将两个集合合并
边都遍历过后，若原图连通，则选定的边和点构成最小生成树；否则最小生成树不存在

相当于：并查集操作+边权排序

例题：还是畅通工程

https://www.nowcoder.com/practice/d6bd75dbb36e410995f8673a6a2e2229?tpId=40&tqId=21479&tPage=1&rp=1&ru=/ta/kaoyan&qru=/ta/kaoyan/question-ranking

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=100;
struct Edge
{
int from;
int to;
int length;
bool operator< (const Edge& e) const//重载小于号
{
return length<e.length;
}
};
Edge edge[MAXN*MAXN];//题干中给出n*(n-1)/2条边
int father[MAXN];
int height[MAXN];
void Initial(int n)//初始化
{
for(int i=0;i<=n;i++)
{
father[i]=i;
height[i]=0;
}
}
int Find(int x)//查找
{
if(x!=father[x])
father[x]=Find(father[x]);
return father[x];
}
void Union(int x,int y)//合并
{
x=Find(x);
y=Find(y);
if(x!=y)
{
if(height[x]>height[y])
father[y]=x;
else if(height[x]<height[y])
father[x]=y;
else
{
father[y]=x;
height[x]++;
}
}
return;
}
int Kruskal(int n,int edgeNum)
{
Initial(n);
sort(edge,edge+edgeNum);//排序
int sum=0;
for(int i=0;i<edgeNum;++i)
{
Edge current=edge[i];
if(Find(current.from)!=Find(current.to))//若该边的两个顶点不在同一集合
{
Union(current.from,current.to);
sum+=current.length;
}
}
return sum;
}
int main()
{
int n;
while(cin>>n)
{
if(n==0)
break;
int edgeNum=n*(n-1)/2;
for(int i=0;i<edgeNum;++i)
{
cin>>edge[i].from>>edge[i].to>>edge[i].length;
}
int answer=Kruskal(n,edgeNum);
cout<<answer<<endl;
}
return 0;
}

4. 最短路径

求图中某两个特定顶点间最短的路径长度。

4.1 Dijkstra算法(大、小规模数据通用)

可有效计算某个顶点到其余所有顶点的最短路径（单源最短路径）。注：不适用于边权为负的图！

将顶点集合V分为两个集合，集合S：已确定的顶点集合，初始只含源点s；集合T，尚未确定的顶点集合，T=V-S
反复从T中取到源点s最近的顶点u，将u加入集合S，然后对所有从u出发的边进行松弛操作(与u相邻点y，取dy与du+边权中的较小值)。
重复操作直至目标结点也加入了集合。

Dijkstra算法采用了贪心的思想，但因为无后效性，所以保证最优结果。

优化：从T中取u时，不必遍历T，而是维护一个元素为顶点的优先队列，T中顶点到s的距离作为这些点的优先级，越近优先级越高。每次取队头元素即可。由于常见的时稀疏图，且一般稀疏图中|E|与V同数量级，所以时间复杂度为O(ElogV)。

例题：继续畅通工程 http://acm.hdu.edu.cn/showproblem.php?pid=1874

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<cstring>
#include<climits>
using namespace std;
const int MAXN=200;
const int INF=INT_MAX;
struct Edge
{
int to;
int length;
Edge(int t,int l):to(t),length(l) {}
};
struct Point
{
int number;//点的编号
int distance;//源点s到该点的距离
Point(int n,int d):number(n),distance(d) {}
bool operator< (const Point& p) const //距离大的优先级小
{
return distance>p.distance;
}
};
vector<Edge> graph[MAXN];//邻接表表示图
int dis[MAXN];//存储源点到各点距离
void Dijkstra(int s)
{
//初始化
priority_queue<Point> PQ;
dis[s]=0;//源点到自己距离为0
PQ.push(Point(s,dis[s]));
while(!PQ.empty())
{
int u=PQ.top().number;//距源点最近的点的编号
PQ.pop();
for(int i=0;i<graph[u].size();++i)
{
int v=graph[u][i].to;//u结点的邻居结点
int d=graph[u][i].length;
if(dis[v]>dis[u]+d)//松弛操作
{
dis[v]=dis[u]+d;
PQ.push(Point(v,dis[v]));
}
}
}
return;
}
int main()
{
int n,m;
while(cin>>n>>m)
{
//初始化
memset(graph,0,sizeof(graph));
fill(dis,dis+n,INF);
while(m--)
{
int from,to,length;
cin>>from>>to>>length;
//对邻接矩阵的初始化
graph[from].push_back(Edge(to,length));
graph[to].push_back(Edge(from,length));
}
int s,t;//起点，终点
cin>>s>>t;
Dijkstra(s);
if(dis[t]==INF)//题干要求终点不可达时输出-1
dis[t]=-1;
cout<<dis[t]<<endl;
}
return 0;
}

4.2 Floyd算法（适合小规模数据）

见前：邻接矩阵+Floyd算法：多源最短路径

5. 拓扑排序

针对有向无环图DAG。可以用队列来保存入度为0的点，但与队列的先进先出无关。

从图中选择入度为0的点，输出
从图中删除入度为0的顶点及以它为起点的边
重复前两步直到当前图为空，或不存在入度为0的点。前者输出的序列就是拓扑序列；后者说明图中有环，无拓扑序列

例题：legal or not

题目大意：ACM群中有师徒关系，师徒关系是单向、可传递的，双向的师徒关系违法。问给定的多对关系中是否存在违法情况？

输入：每组数据第一行为人数n和关系数m(2 <= N, M <= 100)，接下来m行为师徒关系

输出：无违法情况，输出YES；否则输出NO

//样例输入
3 2
0 1
1 2
2 2
0 1
1 0
0 0
//样例输出
YES
NO

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int MAXN=500;
vector<int> graph[MAXN];//邻接表
int inDegree[MAXN];//入度
bool TopologicalSort(int n)
{
queue<int> Q;
for(int i=0;i<n;++i)
{
if(inDegree[i]==0)//保存入度为0的点（的编号
Q.push(i);
}
int number=0;//拓扑序列顶点个数
while(!Q.empty())
{
int u=Q.front();
Q.pop();
number++;
for(int i=0;i<graph[i].size();++i)//遍历这个0入度结点的后继结点
{
int v=graph[u][i];
inDegree[v]--;//后继顶点入度减1
if(inDegree[v]==0)
Q.push(v);
}
}
return n==number;//判断能否产生拓扑排序
}
int main()
{
int n,m;
while(cin>>n>>m)
{
if(n==0&&m==0)
break;
//初始化
memset(graph,0,sizeof(graph));
memset(inDegree,0,sizeof(inDegree));
while(m--)
{
int from,to;
cin>>from>>to;
graph[from].push_back(to);
inDegree[to]++;
}
if(TopologicalSort(n))
cout<<"YES";
else
cout<<"NO";
cout<<endl;
}
return 0;
}

6. 关键路径

基于AOE网——顶点表示时间，有向边表示活动，边权表示活动持续时间的有向图。AOE网用边表示活动；普通有向图用顶点表示活动。用AOE网表示的工程，开始顶点称为源点，入度为0；结束顶点称为汇点，出度为0。

活动的最早开始时间：该活动的前序活动都已完成，可以进行该活动的时间。好比假期一开始就可以开始写作业。对于一个活动，其先序活动的最晚完成时间便是其最早开始时间。题干无特殊要求时，所有节点都初始化为0（设一数组earliest）。

活动的最晚开始时间：该活动的后续活动若要按时完成，则该活动必须开始的时间。好比作业1个月才能做完，而9月开学，则8月1日为最晚开始时间。对于一个活动，其全部后序活动的最早开始时间减去该活动的持续时间，便是其最晚开始时间。题干无特殊要求时，汇点的最晚开始时间初始化为其最早开始时间，其余节点初始化为INF（同样设一latest数组）。

关键路径：从源点到汇点的所有路径中，具有最大路径长度的路径。

关键活动：关键路径上的活动。

确定活动的先后次序要借助拓扑排序。

例题：Instructions Arrangement http://acm.hdu.edu.cn/showproblem.php?pid=4109

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<cstring>
#include<climits>
using namespace std;
const int MAXN=1001;
const int INF=INT_MAX;
struct Edge
{
int to;
int length;
Edge(int t,int l):to(t),length(l) {}
};
vector<Edge> graph[MAXN];//邻接表
int inDegree[MAXN];
int earliest[MAXN];//最早开始时间
int latest[MAXN];//最晚开始时间
void CriticalPath(int n)//求关键路径
{
vector<int> topology;//拓扑序列
queue<int> Q;//存储入度为0的顶点
for(int i=0;i<n;++i)
{
if(inDegree[i]==0)
{
Q.push(i);
earliest[i]=1;//初始化为1
}
}
while(!Q.empty())//确定拓扑序列，同时确定各个关键活动的最早开始时间
{
int u=Q.front();
topology.push_back(u);
Q.pop();
for(int i=0;i<graph[u].size();++i)//遍历这个0入度点的所有后继结点
{
int v=graph[u][i].to;
int l=graph[u][i].length;
earliest[v]=max(earliest[v],earliest[u]+l);//关键活动的最早开始时间要取靠后的值
inDegree[v]--;//后继结点入度减1
if(inDegree[v]==0)
Q.push(v);
}
}
for(int i=topology.size()-1;i>=0;--i)//确定各个活动的最晚开始时间(倒序求解
{
int u=topology[i];
if(graph[u].size()==0)//汇点的最晚开始时间初始化
latest[u]=earliest[u];
else//非汇点的最晚开始时间初始化
latest[u]=INF;
for(int j=0;j<graph[u].size();++j)
{
int v=graph[u][j].to;
int l=graph[u][j].length;
latest[u]=min(latest[u],latest[v]-l);//关键活动的最晚开始时间要取靠前的值
}
}
}
int main()
{
int n,m;
while(cin>>n>>m)
{
//初始化
memset(graph,0,sizeof(graph));
memset(earliest,0,sizeof(earliest));
memset(latest,0,sizeof(latest));
memset(inDegree,0,sizeof(inDegree));
while(m--)
{
int from,to,length;
cin>>from>>to>>length;
graph[from].push_back(Edge(to,length));
inDegree[to]++;
}
CriticalPath(n);
int answer=0;
for(int i=0;i<n;++i)
answer=max(answer,earliest[i]);
cout<<answer<<endl;
}
return 0;
}

最后

以上就是矮小盼望为你收集整理的复试机试算法总结#10：图论的全部内容，希望文章能够帮你解决复试机试算法总结#10：图论所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：学习
浏览次数：128 次浏览
发布日期：2023-11-29 16:10:05
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_10_f3_14_z_18_0.html

复试机试算法总结#10：图论

概述

1. 图的表示

1.1 邻接矩阵

1.2 邻接表

2. 并查集

2.3 连通图判断

2.2 欧拉回路

3. 最小生成树

3.1 Prim算法

3.2 Kruskal算法

4. 最短路径

4.1 Dijkstra算法(大、小规模数据通用)

4.2 Floyd算法（适合小规模数据）

5. 拓扑排序

6. 关键路径

最后

评论列表共有 0 条评论

发表评论取消回复

复试机试算法总结#10：图论

概述

1. 图的表示

1.1 邻接矩阵

1.2 邻接表

2. 并查集

2.3 连通图判断

2.2 欧拉回路

3. 最小生成树

3.1 Prim算法

3.2 Kruskal算法

4. 最短路径

4.1 Dijkstra算法(大、小规模数据通用)

4.2 Floyd算法（适合小规模数据）

5. 拓扑排序

6. 关键路径

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复