PAT之图：遍历、最短路径dijkstra
文章目录
- 0 模板
-
- 邻接矩阵 模板
- 邻接表 模板
- 1 图的遍历
-
- 1.1 邻接矩阵/邻接表 + dfs/bfs
-
- 1013（25：邻接矩阵 + 求连通分量数 + dfs）
- 1021（25：邻接表 + 求连通分量数 + 每个顶点作为根节点的树的深度 + dfs）
- 1034（30：hash + 求带权图的每个连通分量的最大点权重和总权重 + dfs）
- 1076（30：求单源点到每个顶点的层数 + bfs）
- 1.2 图论
-
- 1091（30：三维数组 + bfs）
- 1122（25：根据路径，判断环）
- 1150（25：根据路径，判断环）
- 1126（25：顶点的度+判断连通图）
- 1142（1142：判断最大点集，任意两个点相连）
- 2 最短路径
-
- 2.1 Dijkstra
-
- 模板
-
- dijkstra() 模板
- dfs() 模板
- 1003（25：多条最短路径 + dfs点权重）
- 1018（30：多条最短路径 + dfs）
- 1030（30：多条最短路径 + dfs边权重）
- 拓扑排序
-
-
- 1146（25：判断序列是否为拓扑排序 + 顶点的入度）
-
0 模板
邻接矩阵：（一般）
- 当N<1000
- 带权图
- 插删边 / 顶点
邻接表：
- 当N很大
- 题目明确说了，是稀疏图
邻接矩阵 模板
#include邻接表 模板
#include gra[N];
int visit[N];
void dfs(int v){
...
//
visit[v] = true;
for(int i=0; i<gra[v].size(); i++){
int k = gra[v][i];
if(visit[gra[v][i]]==false){
dfs(gra[v][i]);
}
}
}
int main(){
freopen("in.txt", "r", stdin);
gra.resize(n+1); //从1~n
fill(visit, visit+N, false);
....
gra[a].push_back(b); //无向图
gra[b].push_back(a);
...
//
int cnt=0; //连通分量数
for(int i=1; i<=n; i++){
if(visit[i]==false){
//以i为顶点，遍历所有其它顶点（它能到达的）
dfs(i,1);
cnt++;
}
}
fclose(stdin);
return 0;
}
1 图的遍历
1.1 邻接矩阵/邻接表 + dfs/bfs
1013（25：邻接矩阵 + 求连通分量数 + dfs）
（1）题目
求最少添加几条边使图连通（= 连通分量数 - 1）
（2）代码
#include（3）小结
- 使图连通时，最少添加边数 = 连通分量数 - 1
- 若删除边、顶点，用邻接矩阵
- 删除顶点：标记为访问过
visit[v] = true; - fill 二维数组
int a[N][N];
fill(a[0], a[0] + N*N, 0);
// 不是 fill(a, a + N*N, 0);
1021（25：邻接表 + 求连通分量数 + 每个顶点作为根节点的树的深度 + dfs）
（1）题目
求连通分量数 + 每个顶点作为根节点的树的深度
（2）代码
#include gra[N];
int visit[N];
int depth[N]; //顶点i的深度
int temp_depth; //当前顶点作为根的深度
void dfs(int v, int level){
if(level > temp_depth){
temp_depth = level;
}
//
visit[v] = true;
for(int i=0; i<gra[v].size(); i++){
int k = gra[v][i];
if(visit[gra[v][i]]==false){
dfs(gra[v][i], level+1);
}
}
}
int main(){
//freopen("in.txt", "r", stdin);
int n;
scanf("%d",&n);
gra.resize(n+1); //从1~n
fill(visit, visit+N, false);
for(int i=0; i<n-1; i++){
int a,b;
scanf("%d%d", &a, &b);
gra[a].push_back(b); //无向图
gra[b].push_back(a);
}
//
int cnt=0; //连通分量数
for(int i=1; i<=n; i++){
if(visit[i]==false){
dfs(i,1); //i为根节点
cnt++;
}
}
if(cnt>=2) printf("Error: %d components",cnt);
else{
//每个节点作为根节点，都遍历一遍
for(int i=1; i<=n; i++){
fill(visit, visit+N, false);
temp_depth=0;
dfs(i,1);
depth[i] = temp_depth;
}
//
int max_high=0;
set<int> st;
for(int i=1; i<=n; i++){
if(depth[i] > max_high){
st.clear();
st.insert(i);
max_high = depth[i];
}else if(depth[i]==max_high){
st.insert(i);
}
}
set<int>::iterator it = st.begin();
for(; it!=st.end(); it++){
printf("%d\n", *it);
}
}
//fclose(stdin);
return 0;
}
1034（30：hash + 求带权图的每个连通分量的最大点权重和总权重 + dfs）
（1）题目
hash + 求带权图的每个连通分量的最大点权重和总权重
（2）代码
#include（3）小结
- 此题，hash存储字符串用的是map，字符串对应的id：从1到nameNum-1
map<int , string> mp_itos; //得到string
map<string, int> mp_stoi; //得到int
int nameNum=1;
-
map查找
if(mp.find(key) != mp.end()){
…
} -
段错误
（1）一个或两个测试点 段错误： N小了，数组要开大点
（2）多个测试点 段错误：写的代码数组越界
陷进，N到底为多大（最多顶点数），题目说 的是边最多1000条，N应该至少2000
1076（30：求单源点到每个顶点的层数 + bfs）
（1）
（2）
#include（3）小结
- 根据遍历方向，设计边的方向
如， a fallows b，
gra[a][b]=1 ？ or gra[b][a]=1 ？
对于b来说，求所有不超过L层的间接粉丝转发他微博的人数，即求所有其他节点到b的层数，因此，为了便于遍历，要逆向思维，把b作为根节点，求它到其他节点的层数
存gra[b][a] = 1
1.2 图论
1091（30：三维数组 + bfs）
（2）代码
#include（3）小结
- 顶点太多，用dfs递归内存会爆，因此用bfs
- 如果运行没有输出 或 评测结果为内存超限
则：bfs或dfs没有正确结束 - dfs / bfs中找到邻接点后，至少有2个判断
for(...)
if(visit[.]==false && gra[.][.]==1)
// or if(visit[.]==false && gra[.][.]!=INF)
1122（25：根据路径，判断环）
（1）
（2）代码
#include（3）小结
- 明确什么情况输出 YES：（以下都满足）
1.走得通
2.头尾顶点相同
3.visit[头顶点]=2，其余顶点=1
1150（25：根据路径，判断环）
（2）代码
#include（3）小结
- 明确各种情况
（1）Not a TS cycle：（以下满足一个）
1.不通
2.存在visit[v]=0
3.头！=尾顶点
（2）TS simple cycle：
1.只有visit[头顶点]=2，其余=1
（3）Not a TS cycle
其余
1126（25：顶点的度+判断连通图）
（2）代码
#include（3）小结
- 看懂题目，不是要你证明（根据Eulerian path证明Eulerian），而是要你根据顶点的度判断是不是Eulerian
1142（1142：判断最大点集，任意两个点相连）
（2）代码
#include（3）小结
- 完全图：
有向：m = n*(n-1)
无向：m = n*(n-1)/2 - adjacent.：指v1和v2有边，而不是有路径
2 最短路径
2.1 Dijkstra
模板
- 变量
int D[N]; 初始化：=INF 开始结点v =0
int path[N]; =-1 =-1
vector<int> path[N]; \ \
int PNUM[N]; =0 =1
int W[N]; =0 =weight[v]
- 步骤
第一步：写dijkstra()：只求D[]和path[]
第二步：多条路径选1条，用dfs()从目的点开始，倒求，难点 - dijkstra()模板：顶点下标遍历，共4个for要修改
dijkstra() 模板
（1）求最短路径（1条）
int D[N]; //v到各个顶点的距离
int path[N]; //path[i]为i的前驱
//n个顶点，为0~n-1（一共4个for要修改）
void dijkstra(int v){
fill(visit, visit+N, false); //易遗漏！！！
fill(D, D+N, INF);
fill(path, path+N, -1);
for(int i=0; i<n; i++){
if(gra[v][i]!=INF){
D[i] = gra[v][i];
}
}
D[v] = 0; //!!!
path[v] = -1;
for(int k=0; k<n; k++){
int u=-1, min = INF; //到当前顶点的最短距离
for(int i=0; i<n; i++){
//在D[]中选择一条最短路径
if(visit[i]==false && D[i]<min){
u = i;
min = D[i];
}
}
if(u==-1) break;
visit[u] = true;
for(int i=0; i<n; i++){
// 更新其余顶点
if(visit[i]==false && gra[u][i]!=INF){
if(D[u]+gra[u][i] < D[i]) {
// 1条最短路径（走i更短）
D[i] = D[u]+gra[u][i];
path[i] = u;
}
}
}
}
}
（2）多条最短路径
int D[N]; //v到各个顶点的距离
vector<int> path[N];
//n个顶点，为0~n-1（一共4个for要修改）
void dijkstra(int v){
fill(visit, visit+N, false);
fill(D, D+N, INF);
for(int i=0; i<n; i++){
if(gra[v][i]!=INF){
D[i] = gra[v][i];
}
}
D[v] = 0; //!!!
for(int k=0; k<n; k++){
int u=-1, min = INF; //到当前顶点的最短距离
for(int i=0; i<n; i++){
//在D[]中选择一条最短路径
if(visit[i]==false && D[i]<min){
u = i;
min = D[i];
}
}
if(u==-1) break;
visit[u] = true;
for(int i=0; i<n; i++){
// 更新其余顶点
if(visit[i]==false && gra[u][i]!=INF){
if(D[u]+gra[u][i] < D[i]) {
// 1条最短路径（走i更短）
D[i] = D[u]+gra[u][i];
path[i].clear();
path[i].push_back(u);
}else if(D[u]+gra[u][i] == D[i]){
//多条最短路径（走i和走u一样）
path[i].push_back(u);
}
}
}
}
}
dfs() 模板
vector<int> bestPath, tempPath; //【倒存】：最后一个为 源点
int cntPath=0; //最短路径条数
void dfs(int v, int s){
//s为开始点
tempPath.push_back(v);
if(v==s){
//边界
cntPath++;
...
tempPath.pop_back();
return;
}
for(int i=0; i<path[v].size(); i++){
dfs(path[v][i], s);
}
tempPath.pop_back();
}
1003（25：多条最短路径 + dfs点权重）
（2）代码
#include1018（30：多条最短路径 + dfs）
（2）代码
#include（3）小结
- dfs调整，从目的地sp开始，不是从根节点开始，逆向思维，倒着dfs
1030（30：多条最短路径 + dfs边权重）
（2）代码
#include拓扑排序
- 有向图G，是否存在拓扑排序?
存在： 则无环，进行拓扑排序
不存在，有环 - 对有向无环图进行拓扑排序：所有顶点的序列（可有多个序列）
系列中：所有顶点出现 且 仅1次； V1在V2的前面，则v1到V2必有路径
1146（25：判断序列是否为拓扑排序 + 顶点的入度）
顶点v：
（1）viisit[v] ==0
（2）入度 ==0
满足条件，则删除gra[v][i]的边，visit[v]
结束时：
所有顶点visit[]=1