2.3搜索与图论（最短路）
1.朴素Dijkstra算法
稠密图用邻接矩阵，稀疏图用邻接表存
1≤m≤10^5，所以显然这是个稠密图，由于图中可能存在重边和自环，于是我们用g[N][N]存储每条边的距离时，先要将其初始化为无穷，然后读取时比较一下其与原数组中的值的大小，取最小值存储。Dijkstra方法中，对于每个数都循环一次，先找到没有找到过的距离1点最近的点，把它的st数组中的值设为真，然后遍历所有数更新其距离。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510;
int g[N][N] , dist[N];//g[i][j]存储i到j的距离，dist表示每个点到1的距离
int n , m;
bool st[N];//表示每个点是否能确定到1的距离
int dijkstra()
{
memset(dist , 0x3f , sizeof dist);
dist[1] = 0;
for (int i = 0 ; i < n; i ++)
{
int t = -1;
for (int j = 1 ; j <= n ; j++)
{
if(!st[j] and (t = -1 or dist[j] < dist[t]))//j没有确定最短路并且（t没有复制或者t并不是最短的）
t = j;
}
st[t] = true;
for (int j = 1 ; j <= n ; j++)
{
dist[j] = min(dist[j] , dist[t] + g[t][j]);
}
}
if(dist[n]==0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
cin >> n >> m;
memset(g , 0x3f , sizeof g);//初始化成很大的数
while (m--)
{
int a , b , c;
scanf("%d%d%d" , &a , &b , &c);
g[a][b] = min(c , g[a][b]);
}
cout << dijkstra() <<endl;
return 0;
}2.用堆实现的Dijkstra算法
用新开一个数组w[N]表示权重，有了新的add方法的写法。
用priority_queue<PII , vector<PII> , greater<PII>>即小根堆存储，因为每次循环过后，找的是除了能确定距离的点外距离最小的点，将其的st数组值转为可以确定距离，多以用小根堆从小到大排列的特性可以非常方便的找到那个点。
priority_queue<PII , vector<PII> , greater<PII>>第一个数是距离，因为要用距离来排，第二个数是代表这是第几个点。如果队列不空就一直循环，先把队头取出，如果队头代表的点已经取出过了，就continue取下一个点；如果没有更新一下布尔数组，再对与其相连的点进行枚举，如果现存的距离比dist[k]加两点相连的距离大就表示dist数组可以更新，并且其距离已经确定，加入小根堆中。
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int , int> PII;
const int N = 150010;
int h[N] , e[N] , ne[N] , w[N] , idx;//采用邻接表来存储,不是g[N][N]邻接矩阵
int dist[N];
bool st[N];
int n , m;
void add(int a , int b ,int c)
{
e[idx] = b , w[idx] = c , ne[idx] = h[a] , h[a] = idx++;
//有权重的邻接表存储
}
int dijkstra()
{
memset(dist , 0x3f , sizeof dist);//初始化为无穷大；
dist[1] = 0;//编号为1 的点距离起点的距离为0;
priority_queue<PII , vector<PII> , greater<PII>> heap;//设置小根堆
heap.push({0,1});//小根堆要根据距离来排，即第一个数是距离，第二个数是他是哪个点
//插入1号点的距离为1
while (heap.size())//当堆不空
{
auto t = heap.top();//取出队头并删除队头
heap.pop();
int k = t.second , distance = t.first;//t是第k个点，到起点距离为distance
if (st[k]) continue;//此点冗余
st[k] = true;
for (int i = h[k] ; i != -1 ; i = ne[i])//循环
{
int j = e[i];
if (dist[j] > dist[k] + w[i])//如果dist值可以更新
{
dist[j] = dist[k] + w[i];//那就更新，并将其加入堆
heap.push({dist[j] , j});
}
}
}
if(dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
cin >> n >> m;
memset(h , -1 , sizeof h);//常规操作，把表头指向-1;
while(m--)
{
int a, b ,c;
scanf("%d%d%d" , &a , &b , &c);
add(a , b , c); //采用堆就不用考虑重边的问题
}
cout << dijkstra() <<endl;
return 0;
}3. Bellman Ford算法
处理最多经过k条边，拥有负权回路的最短路
先枚举k次操作，每次操作枚举m条边，看看能不能更新
代码如下：
#include <iostream>
#include <cstring>
#include <algorithm>
const int N = 510 , M = 10010;
int dist[N] , backup[N];
using namespace std;
struct Edge{ //结构体
int a , b , w;
}edges[M];
int n , m , k;
void bellman_ford()
{
memset(dist , 0x3f , sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++ ) //枚举k次
{
memcpy(backup , dist , sizeof dist);
for (int j = 0 ; j < m ; j ++) //枚举每条边
{
int a = edges[j].a , b = edges[j].b , w = edges[j].w;
dist[b] = min(dist[b] , backup[a] + w);
}
}
}
int main()
{
cin >> n >> m >> k;
int i = 0;
for (int i = 0; i < m; i ++ )
{
int a , b , w;
scanf("%d%d%d" , &a , &b , &w);
edges[i] = {a , b , w};
}
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible"); //如果dist[n]依然很大
else cout << dist[n] << endl;
return 0;
}4. spfa算法
代码跟堆优化的dijkstra比较相似，y总推荐使用
说很多正权边的最短路本来是用dijkstra算法，事实上可能spfa也可以过
处理边权可能为负数，不存在负权回路的最短路
代码如下：
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int h[N] , e[N] , w[N] , ne[N] , idx;
int n , m;
int dist[N];
bool st[N]; //存储每个数在不在队列q中
void add(int a , int b , int c)
{
e[idx] = b , w[idx] = c , ne[idx] = h[a] , h[a] = idx ++;
}
void spfa()
{
memset(dist , 0x3f , sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
while (q.size())
{
int t = q.front();
st[t] = false; //t出队，将其状态变更
q.pop();
for (int i = h[t] ; i != -1 ; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j]) //如果j不在队列中
{
st[j] = true; //将j加入队列
q.push(j);
}
}
}
}
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
while (m -- )
{
int a , b , c;
scanf("%d%d%d" , &a , &b , &c);
add(a , b , c);
}
spfa();
if (dist[n] == 0x3f3f3f3f) puts("impossible");
else cout << dist[n] << endl;
return 0;
}4.1 spfa算法判负环
跟spfa本体大差不差
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 2010 , M = 10010;
int h[N] , e[M] , ne[M] , w[M] , idx;
int dist[N] , cnt[N];
bool st[N]; //该数是否进队列
int n , m;
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
bool spfa()
{
queue<int>q;
//并不是求1到n的路径有没有负环，有可能1到不了，所以把所有点加进去
for (int i = 1; i <= n; i ++ )
{
q.push(i);
st[i] = true;
}
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t] ; i != -1 ; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1 ;
if (cnt[j] >= n) return true; //如果到j的路径经过大于等于n个点
if (!st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
return false;
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
while (m -- )
{
int a , b , c;
scanf("%d%d%d" , &a , &b , &c);
add(a, b, c);
}
if (spfa()) puts("Yes");
else puts("No");
return 0;
}5. Floyd多源汇最短路
代码挺简单，三重循环
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210;
int g[N][N];
int n , m , k;
void floyd()
{
for (int k = 1 ; k <= n ; k ++) //三重循环
for (int i = 1 ; i <= n ; i ++)
for (int j = 1 ; j <= n ; j ++)
g[i][j] = min(g[i][j] , g[i][k] + g[k][j]);
}
int main()
{
cin >> n >> m >> k;
memset(g , 0x3f , sizeof g); //除了相同的点，其余边全部初始化成无穷
for (int i = 1 ; i <= n ; i ++)
g[i][i] = 0;
while (m -- )
{
int a , b , c;
scanf("%d%d%d" , &a , &b , &c);
g[a][b] = min(g[a][b] , c); //读入所有边
}
floyd();
while (k --)
{
int a , b;
scanf("%d%d" , &a , &b);
if (g[a][b] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n" , g[a][b]);
}
return 0;
}
浙公网安备 33010602011771号