【王道机试指南学习笔记】第十一章 图论

最新推荐文章于 2024-04-20 21:11:30 发布
最新推荐文章于 2024-04-20 21:11:30 发布
阅读量188 收藏
点赞数
分类专栏： 王道机试指南 学习笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42735614/article/details/108632855
版权

【Nan's 王道机试指南学习笔记】第十一章 图论

前言与提示

图论有关问题——并查集、最小生成树、最短路径、拓扑排序等。
抽象数据的图结构，主要介绍邻接矩阵和邻接表这两种实现方式。

11.1 概述

重点提醒

图是由顶点(Vertex)集合V和边(Edge)集合E组成。常用V和E的模分析算法的复杂度。
图根据边集合E中的元素(u,v)是否有次序，图被分为无向图，有向图。
在这里插入图片描述
1) 邻接矩阵——二维数组
最直接的图结构实现方式，用一个二维矩阵来表示。
二维矩阵的每个单元表述一对顶点之间的邻接关系。
在这里插入图片描述
邻接矩阵的缺陷：
①若想遍历与某顶点相邻的所有顶点，需要依次遍历二维数组中某行的所有元素，逐个判断相邻，时间利用率低；
②若为稀疏图会产生稀疏矩阵，浪费空间。
适合稠密图，且需频繁地判断某特定顶点对是否相邻时，才比较适宜

2) 邻接表——向量实现 效率更高！多用！
邻接表为每个顶点建立一个单链表，保存与该顶点相邻的所有顶点的相关信息。
在遍历与某个特定顶点相邻的顶点时，邻接表效率很高。
与邻接矩阵相比：当需要判断两个定点是否存在关系时，需要遍历所有邻接顶点才能确定。
适合存在大量遍历邻接顶点、较少判断关系的情况

11.2 并查集

重点提醒

处理 不交集的 合并和查询问题：
①判断任意两个元素是否属于同一个集合
②按照要求合并不同的集合
（1）集合用树结构表示
在这里插入图片描述
（2）查找——根据根节点判断集合
在这里插入图片描述
（3）合并
在这里插入图片描述
为避免合并出不好的树形，退化成链表，在合并两树时，在查找到某个特定结点的根节点的同时，将其与根节点之间的所有结点都直接指向根节点，这个过程被称为 路径压缩。
在合并时，总是将高度较低的树作为子树进行合并，提高合并后的查找效率。（影响查找效率的时树高）

题目练习

例题11.1 畅通工程（浙大复试）

题目OJ网址（牛客网）：
https://www.nowcoder.com/practice/4878e6c6a24e443aac5211d194cf3913
并查集最常用来 判断图是否为连通图，或用来求图的连通分量。
无向图G的一个极大连通子图称为G的一个连通分量

//将每个元素看为一个集合，然后通过并查集合并集合，然后再将余下的集合连接起来即可
#include<iostream>
#include<vector>

using namespace std;
int main(){
    int n,m;
    while(cin>>n>>m){
        int t = n;
        //vector(int nSize,const t& t):创建一个vector，元素个数nSize,且值均为t
        vector<int> v(n+1,-1);
        while(m--){
            int x,y;
            cin>>x>>y;
            int a=x,b=y;
            while(v[a]!=-1) a=v[a];//找代表元素
            while(v[b]!=-1) b=v[b];
            if(a==b) continue;
            else {
                v[b]=x;
                t-=1;//合并
            }
        }
        v.clear();
        cout<<t-1<<endl;
    }
}

在这里插入图片描述
在这里插入图片描述

11.3 最小生成树

重点提醒

题目练习

例题10.3 二叉排序树（华科复试）

题目OJ网址（牛客网）：

11.4 最短路径

重点提醒

求最短路径问题的经典算法——Dijkstra算法。
在这里插入图片描述
采用==优先队列==进行优化可以大幅降低算法时间复杂度
数组dis：来保存源点到各个顶点的最短距离
一个保存已经找到了最短路径的顶点的集合：T（myQueue）
初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。
初始时，集合T只有顶点s。然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否 < 源点直接到达，如果是，那么就替换这些顶点在dis中的值。

题目练习

例题11.6 畅通工程续（浙大复试）

#include<iostream>
#include<vector>
#include<queue>
#include<cstdio>
#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;//源点到该点的距离
    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> myQueue;
    dis[s]=0;
    myQueue.push(Point(s,dis[s]));
    while(!myQueue.empty()){
        int u = myQueue.top().number;//离源点最近的点的序号
        myQueue.pop();
        for(int i= 0;i<graph[u].size();i++){//遍历新的点为起点可到的所有路
            //新顶点
            int v = graph[u][i].to;
            int d = graph[u][i].length;
            if(dis[v]>dis[u]+d){
                dis[v]=dis[u]+d;//如果比直接到v路径短，则替换
                myQueue.push(Point(v,dis[v]));//找到一个路径点
            }
        }
            
    }
    return ;
}
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(graph,0,sizeof(graph));//初始化图
        //fill()函数参数：fill(first,last,val); first 为容器的首迭代器，last为容器的末迭代器，val为将要替换的值
        fill(dis,dis+n,INF);//距离初始化为正无穷
        while(m--){
            int from,to,length;
            scanf("%d%d%d",&from,&to,&length);
            //双向道路
            graph[from].push_back(Edge(to,length));
            graph[to].push_back(Edge(from,length));
        }
        int s,t;//起点与终点
        scanf("%d%d",&s,&t);
        Dijkstra(s);
        if(dis[t] == INF) dis[t]=-1;
        printf("%d\n",dis[t]);
    }
    return 0;
}

例题11.7 最短路径问题（浙大复试）

题目OJ网址（牛客网）：
https://www.nowcoder.com/practice/e372b623d0874ce2915c663d881a3ff2
跟上题很像，只不过加了个price，dijkstra的判断条件也要考虑到同距离更短花费~

#include<iostream>
#include<vector>
#include<queue>
#include<cstdio>
#include<cstring>
#include<climits>

using namespace std;
const int MAXN = 1001;
const int INF = INT_MAX;
struct Edge{
    int to;
    int length;
    int price;
    Edge(int t,int l,int p):to(t),length(l),price(p){}
};
struct Point{
    int number;//点编号
    int distance;//源点到该点的距离
    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];//源点到各点的距离
int cost[MAXN];//记录花费

void Dijkstra(int s){
    priority_queue<Point> myQueue;
    dis[s]=0;
    cost[s]=0;
    myQueue.push(Point(s,dis[s]));
    while(!myQueue.empty()){
        int u = myQueue.top().number;//离源点最近的点的序号
        myQueue.pop();
        for(int i= 0;i<graph[u].size();i++){//遍历新的点为起点可到的所有路
            //新顶点
            int v = graph[u][i].to;
            int l = graph[u][i].length;
            int p = graph[u][i].price;
            //最短距离及其花费，如果最短距离有多条路线，则输出花费最少的
            if(dis[v]>dis[u]+l||(dis[v]==dis[u]+l && cost[v]>cost[u]+p)){
                dis[v] = dis[u]+l;//如果比直接到v路径短，则替换
                cost[v] = cost[u]+p;
                myQueue.push(Point(v,dis[v]));//找到一个路径点
            }
        }

    }
    return ;
}
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0&&m==0) break;
        memset(graph,0,sizeof(graph));//初始化图
        //fill()函数参数：fill(first,last,val); first 为容器的首迭代器，last为容器的末迭代器，val为将要替换的值
        fill(dis,dis+n+1,INF);//距离初始化为正无穷 1开始编号点
        fill(cost,cost+n+1,INF);//距离初始化为正无穷
        while(m--){
            int from,to,length,price;
            scanf("%d%d%d%d",&from,&to,&length,&price);
            //双向道路
            graph[from].push_back(Edge(to,length,price));
            graph[to].push_back(Edge(from,length,price));
        }
        int s,t;//起点与终点
        scanf("%d%d",&s,&t);
        Dijkstra(s);
        if(dis[t] == INF) dis[t]=-1;
        printf("%d %d\n",dis[t],cost[t]);
    }
    return 0;
}

习题11.6 最短路径（上交复试）

题目OJ网址（牛客网）：
https://www.nowcoder.com/questionTerminal/a29d0b5eb46b4b90bfa22aa98cf5ff17
这题路径长度2的k次方。
所以有两种方法：
第一种就是使用大整数+Dijkstra（我自己改了半天没改对 我用longlong也不可 要用string）
第二种就是使用并查集的方法，如果两个点不属于一个集合，则合并这两个点

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

const int MAXN = 200;
using namespace std;
 
struct Edge{
    int to;                                    /*边的一个顶点*/
    string length;                             /*边长*/
    Edge(int t, string l): to(t), length(l) {}
};
 
struct Point{
    int number;                                /*点编号*/
    string distance;                    /*距离源点距离*/
    Point(int n, string d): number(n), distance(d) {}
    bool operator<(const Point &p) const{
        return distance>p.distance;
        /*因为下面用到优先级队列，优先级队列默认是大根堆，而我们要用的是小根堆，所以注意这里return是大于号*/
    }
};
 
vector<Edge> graph[MAXN];                   /*使用邻接表存储图*/
string dis[MAXN];                       /*距离源点的距离*/
 
string adds(string s1, string s2){             /*字符串加法*/
    int carry=0, current;
    int i=s1.size()-1;
    int j=s2.size()-1;
    string ans;
    while(i>-1 && j>-1){
        current=s1[i]-'0'+s2[j]-'0'+carry;
        carry=current/10;
        ans+=current%10+'0';
        i--;
        j--;
    }
    while(i>-1){
        current=s1[i]-'0'+carry;
        carry=current/10;
        ans+=current%10 + '0';
        i--;
    }
    while(j>-1){
        current=s2[j]-'0'+carry;
        carry=current/10;
        ans+=current%10+'0';
        j--;
    }
    if(carry)                /*加法还有进位要再加1*/
        ans+="1";
    reverse(ans.begin(),ans.end());     /*因为ans正好与正确结果相反，所以使用reverse函数对字符串进行求逆，头文件是algorithm*/
    return ans;
}
 
string multiple(string s,int k){       /*字符串乘法*/
    int carry=0;
    for(int i=s.size()-1;i>-1;i--){
        int current=(s[i]-'0')*k+carry;
        s[i]=current%10+'0';
        carry=current/10;
    }
    if(carry)
        s=to_string(carry)+s;
    return s;
}
 
int Divide(string s){              /*字符串除法用于求模*/
    int remainder=0;
    for(int i=0;i<s.size();i++){
        int current=10*remainder+s[i]-'0';
        remainder=current%100000;
        s[i]=current/100000;
    }
    return remainder;
}

bool cmpString(string s1,string s2){     /*两个字符串数比较大小*/
    if(s1.size()>s2.size()) return true;  /*位数多则一定大*/
    else if(s1.size()<s2.size()) return false;
    else{
        for(int i=0;i<s1.size();i++){
            if(s1[i]-'0'>s2[i]-'0') return true;
            else if(s1[i]-'0'<s2[i]-'0') return false;
        }
    }
    return false; /*两个数相等*/
}
 
void Dijkstra(){
    dis[0]="0";
    priority_queue<Point> Q;         /*使用优先级队列，方便找出距离源点最近的点*/
    Q.push(Point(0,dis[0]));
    while(!Q.empty()){
        int u=Q.top().number;
        Q.pop();
        for(int i=0;i<graph[u].size();i++){
            int v=graph[u][i].to;
            string d=graph[u][i].length;
            string l=adds(dis[u],d);
            if(cmpString(dis[v],l)){
                dis[v]=l;
                Q.push(Point(v,dis[v]));
            }
        }
    }
    return ;
}
 
int main(){
    int n, m, a, b;
    string INF="1";
    for(int i=0;i<1000;i++){   /*尽可能求一个大点的数用于路径长度的初始化*/
        INF=multiple(INF,2);
    }
 
    while(cin>>n>>m){
        string l="1";
        memset(graph,0,sizeof(graph));     /*初始化*/
        fill(dis,dis+n,INF);
        for(int i=0;i<m;i++){
            cin>>a>>b;
            graph[a].push_back(Edge(b,l));
            graph[b].push_back(Edge(a,l));
            l=multiple(l,2);
        }
        Dijkstra();
        for(int i=1;i<n;i++){
            if(dis[i]==INF)
                cout<<-1<<endl;
            else
                cout<<Divide(dis[i])<<endl;
        }
    }
    return 0;
}

法二：并查集？看不懂…
披着最短路径外衣的最小生成树。
因为路径长度是从2^0 开始，其实举例到第3条路径就可以发现：22=4>20+2^1，也就是说，当一条边的两个端点不在同一集合时，这条边的长度就是这两点间的最短距离，可以直接取mod，这时只用更新一下两个集合里各点间的距离就行，而如果这条边的两个端点在同一集合，那么这条边就可以直接舍去了，因为这条边的长度将会比之前出现的所有边长度的总和还要长。
在这里插入图片描述

习题11.7 I Wanna Go Home

题目OJ网址（牛客网）：
https://www.nowcoder.com/questionTerminal/0160bab3ce5d4ae0bb99dc605601e971

题目中有个最多只能转变1次阵营的限制。
由题意可知，M出发地是1号，目的地总是2号，从1-2必须转变一次阵营，所以就要求在这之前不能出现2-1的
情况，出现了就不符合题目的要求，所以就在Dijkstra中判断松弛条件的时候加一个判断语句就能求解了

#include<iostream>
#include<vector>
#include<queue>
#include<cstdio>
#include<cstring>
#include<climits>

using namespace std;
const int MAXN = 605;
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;//源点到该点的距离
    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];//源点到各点的距离
int flag[MAXN];

void Dijkstra(int s){
    priority_queue<Point> myQueue;
    dis[s]=0;
    myQueue.push(Point(s,dis[s]));
    while(!myQueue.empty()){
        int u = myQueue.top().number;//离源点最近的点的序号
        myQueue.pop();
        for(int i= 0;i<graph[u].size();i++){//遍历新的点为起点可到的所有路
            //新顶点
            int v = graph[u][i].to;
            int d = graph[u][i].length;
            if(!(flag[u-1] == 2 && flag[v-1] == 1)&&dis[v]>dis[u]+d){
                dis[v]=dis[u]+d;//如果比直接到v路径短，则替换
                myQueue.push(Point(v,dis[v]));//找到一个路径点
            }
        }

    }
    return ;
}
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(graph,0,sizeof(graph));//初始化图
        //fill()函数参数：fill(first,last,val); first 为容器的首迭代器，last为容器的末迭代器，val为将要替换的值
        fill(dis,dis+n,INF);//距离初始化为正无穷
        //memset(dis, 0x3f, sizeof(dis));
        while(m--){
            int from,to,length;
            scanf("%d%d%d",&from,&to,&length);
            //双向道路
            graph[from].push_back(Edge(to,length));
            graph[to].push_back(Edge(from,length));
        }
        for(int i = 0; i < n; ++i){
            cin >> flag[i];
        }
        Dijkstra(1);//出发地1，目的地2
        if(dis[2] == INF) dis[2]=-1;
        printf("%d\n",dis[2]);
    }
    return 0;
}
Liareee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道C语言督学营oj练习附个人学习感受（持续更新ing）
qq_43498726的博客
02-23 7250
初级阶段 个人感受分享： 初级阶段比较基础，但像龙哥说的那样，即使是科班出身，也需要听课。龙哥讲课把C语言以及之后考研用到的数据结构、计算机组成原理都有融合，也带着一步一步进行进行调试，在代码运行和问题解决方面有很大的收获。 这里建议大家上完课立马去写作业进行巩固，否则会对知识有所遗忘，有条件的朋友可以多刷几次课程加深记忆与理解。 关于oj，有时候确实很烦人。但现在BAT企业以及考研复试都是使用oj系统，所以也是刚好的帮助大家适应。我也曾多次被oj折磨的痛不欲生，但在这个过程中也是有提升自己的耐心，当你听到
考研/保研机试（王道机试指南+算法笔记上机指南）
04-24
考研/保研机试，包括王道机试指南、算法笔记上机指南，足以应付各大机试、CSP等
王道论坛机试指南学习笔记（四）图论
qq_42290765的博客
05-06 303
文章目录1. 并查集- 基本表示- 集合的合并- 查找根节点- 查找连通分量个数2. 最小生成树MST- 定义- Kruskal算法- java代码3. 最短路径- 定义- Floyd算法- Dijkstra算法4. 拓扑排序- 定义- 算法- 代码 1. 并查集 - 基本表示 用数组保存树的节点以及他们之间的关系，使用**双亲表示法** 根节点的双亲通常用”-1“表示，其他节点则存储其唯一的双...
《王道机试》：笔记（一）经典入门
宴夜小丑的博客
05-08 1270
《王道机试》学习笔记1、排序在c++中，推荐使用sort方法，进行块排sort比较升序，如果想用降序可以重写布尔方法，调用时sort(a,a+n,compare)bool compare(int a,int b){ if(a&gt;b)return true; else return false; }对于结构体的复杂排序，也可以使用自定义的布尔方法。首先按成绩由低到高，成绩相同时按照年龄从低到高b...
王道机试 DP篇
一位浪漫的极客
06-24 356
summary 递推求解 N级楼梯上楼问题：一次可以走一级或两级，问有多少种上楼方式。 思路：首先设有n级台阶上有f(n)种方式；倒推，从最后一步开始想：因为在最上面一级可以退1步或2步，也就是说，f(n)可以由f(n-1)和f(n-2)相加得到，也就是到达n-2级的方式数 加上到达n-1级的方式数。 so，状态转移方程get：f(n)=f(n-1)+f(n-2)。其实也就是斐波...
王道机试上机指南
03-20
王道关于考研机试的指导书，原来可以配合练习的九度oj已关闭，但这本书依然可以给准备机试的道友们很大帮助
王道C语言督学营oj练习（全部更新完成）
热门推荐
weixin_51330523的博客
04-10 3万+
王道C语言督学营oj练习及答案
王道C语言督学营oj练习（2024.3.16-持续更新中）
weixin_68700848的博客
03-18 1472
王道C语言督学营oj练习
王道c语言督学营/OJ练习题，带解析版（25年持续更新）
最新发布
star_asd的博客
04-20 627
用于记录我的学习过程，也方便各位借鉴练习。
王道第二章链表相关oj题及之后的练习(详解)
qq_53010164的博客
08-22 343
此篇为参考王道即力扣相关的题目以及自己的思路,只为参考,只是本人的学习思路
我的OJ锻炼：我的OJ练习
02-27
我的OJ锻炼：我的OJ练习
王道算法题
02-13
非原创的为什么能要15c币，csdn别这样玩了 ............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
浙工大OJ 194题代码
01-01
浙江工业大学194题的代码，有些太简单的没有放进去，有助于学习～
OJ题目及源码
12-28
学校OJ网站的题目及源码 网址：http172.21.85.19ZQUOJhomeHomePage.jsp 想提高编程水平的娃儿平时可以练一练
计算机考研 机试指南-王道论坛
05-08
内容推荐 目前已有越来越多的高校采用上机考试的形式来考查学生的动手编程能力，对于以应试为主的大学教学模式，上机往往是学生的薄弱环节。本书由浅入深、从简到难讲解了机试的相关考点，并精选名校的复试上机真题作为例题和习题，以给大家提供最可靠的练习指导。书中的所有机试试题在九度OJ（ac.jobdu.com）均有收录，建议同学们在阅读本书时，结合上机练习，自己动手才是王道！ 作者简介 王道论坛（www.cskaoyan.com）组织名校高分选手，编写了4本单科辅导书。单科书是基于王道之前作品的二代作品，不论是编排方式，还是内容质量都较前一版本的王道书有了较大的提升。这套书也参考了同类优秀的教材和辅导书，更是结合了高分选手们自己的复习经验。无论是对考点的讲解，还是习题的选择和解析，都结合了他们对专业课复习的独特见解 目录 第1章 从零开始 1 一、机试的意义 1 二、机试的形式 1 三、评判结果 3 四、复杂度的估计 4 五、OJ的使用 5 总结 6 第2章 经典入门 7 一、排序 7 二、日期类问题 14 三、Hash的应用 21 四、排版题 25 五、查找 30 六、贪心算法 36 总结 4
王道C语言督学营OJ题解合集（24考研人持续更新ing）
shuxiachai的博客
10-14 2729
王道考研教育C语言督学营OJ题解
王道 OJ Online Judge 中级-day6作业
fredvioce的博客
03-10 1794
目录代码使用纯 C 语言编码链接中级-day6作业DescriptionInputOutput输入输出样例注意点AC代码 代码使用纯 C 语言编码 链接 http://oj.lgwenda.com/problem/19 中级-day6作业 Description 新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6 Input 读取标准输入
王道OJ习题答案（初级阶段）
jinzhi66的博客
07-11 3952
#include <stdio.h> int main() { printf("hello wangdao\n"); system("pause"); //让黑色的窗口控制台停留 return 0; } 2. #include <stdio.h> int main() { int a,b; scanf("%d %d",&a, &b); printf("%d",a+b); return ...........
王道C语言督学营OJ题解合集（25考研人缓慢更新ing）
qq_61156776的博客
01-21 898
课时2作业1课时2作业2课时3作业1课时2作业3。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值