图论这个东东怪难的，写个博客总结一下吧。
首先先贴一个图论的学习路线吧：https://blog.csdn.net/Fire_to_cheat_/article/details/80028763
再贴上从别处收集来的题：https://blog.csdn.net/cxb569262726/article/details/7859515（把这些刷完你就无敌了）
部分图片和文字来自：https://www.bilibili.com/video/av64263196/?p=1
最短路问题就是给定起点和终点，在途中找到一条路径使得沿此路径上各边的权值总和最小。
解决最短路问题我们有四种算法：
Dijkstra算法，Bellman Ford算法，SPFA算法，Floyd算法
Dijkstra算法：
Dijstra算法思想：设有两个顶点集合S和T，集合S中存放的图中已经找到最短路径的顶点，集合T中存放图中剩余顶点。初始状态的时候，集合S中只包含源点v0，然后不断从集合T中选取到顶点v0路径长度最短的顶点v并入到集合S中去，集合S每并入一个新的顶点，都要修改顶点v0到集合T中顶点的最短路径长度值。
算法实现：
1.设置两个顶点的集合S和T
a) S中存放已找 到最短路径的顶点，初始时，集合S只有 一个顶点，
即源点v0.
b)下中存放当前还未找到最短路径的顶点
2.在工集合中选取当前最短的-条最短路径(v0, … vk)， 从而将
vk加入到顶点集合S中，并且修改源点v0到T中各顶点的最短路径长度。
3.重复步骤2，直到所有的顶点都被加入集合S中。
我们根据图来解释如何进行操作：
1.首先求出长度最短的一条最短路径: 0 -> 2,长度为5 (2号点)。
2.顶点2的最短路求出来之后，0到其他顶点的最短路径长度有可能要改变，比如0->1从原来的∞变成了20，0->5从原来的∞变成了12.这样次短的最短路就是12 (5号点) .
3.5的最短路求出后，0到其他点的最短路还会发生改变。比如0 ->3从原来的30变为了22，0->4也从∞变为了28。这时第三短的最短路就确定了，是20 (1号点) .
4.之后再依次确定第四短的最短路是22 (3号点) .
5.第五短的最短路是28 (4号点).
下面我们做个板子题练练手：
传送门：https://vjudge.net/problem/HDU-2544
AC代码如下：
//Dijstra算法不加堆优化，时间复杂度O(n^2),利用邻接矩阵存图
#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<list>
#include<cmath>
#include<algorithm>
#define lson node<<1,st,mid
#define rson node<<1|1,mid+1,ed
#define mem(a,x) memset(a,x,sizeof(a))
#define me(a) memset(a,0,sizeof(a))
#define IOS ios::sync_with_stdio(false)
#define lowbit(x) x&(-x)
#define up(i,x,y) for(long long i=x;i<y;i++)
#define down(i,x,y) for(long long i=x;i>=y;i--)
#define in freopen("in.txt","r",stdin)
#define out freopen("out.txt","w",stdout)
typedef long long ll;
const ll mod=1e9+7;
const ll INF=0x3f3f3f3f;
const int maxn=10005;
const double pi = acos(-1.0);
using namespace std;
ll n,m;
ll edge[maxn][maxn],dist[maxn];
bool vis[maxn];
void dijstra(ll u){
mem(dist,INF);
for(ll i=1;i<=n;i++){
vis[i]=false;
dist[i]=edge[u][i];
}
vis[u]=true;
for(ll i=1;i<n;i++){
ll min=INF,v=u;
for(ll j=2;j<=n;j++){
if(!vis[j]&&dist[j]<min){
min=dist[j];
v=j;
}
}
vis[v]=true;
for(ll j=2;j<=n;j++){
if(!vis[j]&&dist[v]+edge[v][j]<dist[j]){
dist[j]=dist[v]+edge[v][j];
}
}
}
}
int main(){
while(~scanf("%lld%lld",&n,&m),n,m){
for(ll i=1;i<=n;i++){
for(ll j=1;j<=n;j++){
if(i!=j) edge[i][j]=INF;
else edge[i][j]=0;
}
}
while(m--){
ll u,v,w;
scanf("%lld%lld%lld",&u,&v,&w);
edge[u][v]=min(w,edge[u][v]);
edge[v][u]=min(w,edge[v][u]);
}
dijstra(1);
printf("%lld\n",dist[n]);
}
}
顺便贴一个单源最短路二重权值的问题：
传送门：HDU 3790
简单思路：二重权值和一重其实本质上区别不大，这个题是先看最短路，再看花费时间，我们可以先求最短路，再取里面时间最小的。
AC代码
//注意有没有重边问题
#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<list>
#include<cmath>
#include<algorithm>
#define lson node<<1,st,mid
#define rson node<<1|1,mid+1,ed
#define mem(a,x) memset(a,x,sizeof(a))
#define me(a) memset(a,0,sizeof(a))
#define IOS ios::sync_with_stdio(false)
#define lowbit(x) x&(-x)
#define up(i,x,y) for(long long i=x;i<y;i++)
#define down(i,x,y) for(long long i=x;i>=y;i--)
#define in freopen("in.txt","r",stdin)
#define out freopen("out.txt","w",stdout)
typedef long long ll;
const ll mod=1e9+7;
const ll INF=0x3f3f3f3f;
const int maxn=10005;
const double pi = acos(-1.0);
using namespace std;
bool vis[maxn];
struct code{
int w;
int t;
};
int n,m;
code edge[maxn][maxn],dist[maxn];
void dijstra(int u){
mem(vis,false);
dist[u].w=0;
dist[u].t=0;
for(int i=1;i<=n;i++){
dist[i].w=edge[u][i].w;
dist[i].t=edge[u][i].t;
}
vis[u]=true;
for(int i=2;i<=n;i++){
int min=INF,v=u;
for(int j=1;j<=n;j++){
if(!vis[j]&&dist[j].w<min){
min=dist[j].w;
v=j;
}
}
vis[v]=1;
for(int j=1;j<=n;j++){
if(!vis[j]&&dist[v].w+edge[v][j].w<dist[j].w){
dist[j].w=dist[v].w+edge[v][j].w;
dist[j].t=dist[v].t+edge[v][j].t;
}
else if(!vis[j]&&dist[j].w==dist[v].w+edge[v][j].w){
if(dist[j].t>dist[v].t+edge[v][j].t)
dist[j].t=dist[v].t+edge[v][j].t;
}
}
}
}
int main(){
while(~scanf("%d%d",&n,&m),n,m){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(i!=j) edge[i][j].w=INF,edge[i][j].t=INF;
else edge[i][j].w=0,edge[i][j].t=0;
}
}
while(m--){
int u,v,w,t;
scanf("%d%d%d%d",&u,&v,&w,&t);
if(edge[u][v].w>w){
edge[u][v].w=edge[v][u].w=w;
edge[u][v].t=edge[v][u].t=t;
}
}
int l,r;
scanf("%d%d",&l,&r);
dijstra(l);
printf("%d %d\n",dist[r].w,dist[r].t);
}
}
Dijkstra算法的堆优化：
这里采用了优先队列和链式前向星对dijkstra算法进行优化。
优先队列插入操作的时间复杂度是O(logn)，所以直接把直接复杂度降下来了，可是存图的时候有个问题，如果我们采用邻接矩阵存图，那么空间复杂度就是O(n^2)，对其优化就失去了意义，所以我们采用链式前向星存图。
优先队列的基本操作：点我🤪
链式前向星：点我😀
先贴个题：HDU2544
//堆优化, 复杂度O(nlogn)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<list>
#include<cmath>
#include<algorithm>
#include<fstream>
#include<sstream>
#define lson node<<1,st,mid
#define rson node<<1|1,mid+1,ed
#define mem(a,x) memset(a,x,sizeof(a))
#define me(a) memset(a,0,sizeof(a))
#define IOS ios::sync_with_stdio(false)
#define lowbit(x) x&(-x)
typedef long long ll;
const ll mod=1e9+7;
const ll INF=0x3f3f3f3f;
const ll maxn=1e5+5;
const double pi = acos(-1.0);
using namespace std;
ll n,m;
int dist[maxn],head[maxn];
bool vis[maxn];
struct code{
int to,w,next;
}edge[maxn];
struct node{//优先队列的重载
int to,w;
bool operator <(const node &x) const{
return w>x.w;//最小值优先
//return w<x.w//最大值优先
}
};
priority_queue<node>q;
int cnt;
void intn(){//初始化
cnt=0;
mem(head,-1);
mem(vis,false);
mem(dist,INF);
}
void add(int u,int v,int w){//链式前向星加边操作
cnt++;
edge[cnt].to=v;
edge[cnt].w=w;
edge[cnt].next=head[u];
head[u]=cnt;
}
void dijkstra(int u){//优化dijkstrea算法
dist[u]=0;
q.push(node {u,dist[u]});
while(!q.empty()){
node x=q.top();
q.pop();
if(vis[x.to]) continue;
vis[x.to]=true;
for(int i=head[x.to];i!=-1;i=edge[i].next){
int v=edge[i].to;
if(dist[v]>dist[x.to]+edge[i].w){
dist[v]=dist[x.to]+edge[i].w;
q.push(node {v,dist[v]});
}
}
}
}
int main(){
while(~scanf("%lld%lld",&n,&m),n,m){
intn();
while(m--){
ll u,v,w;
scanf("%lld%lld%lld",&u,&v,&w);
add(u,v,w);
add(v,u,w);
}
dijkstra(1);
printf("%lld\n",dist[n]);
}
}
1617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
