标签：idx int 短路 ++ st color include 合集 模板
$\color{#39c588} {关于最短路} $
$\color{purple} {首先是最短路的算法选择思路捏,直接来个Y总的图} $
++$\color{purple} {单源汇问题} $++
$\color{orange} {朴素版Dijkstra} $
实现思路
//朴素版Dijkstra o(n^2) -- 处理稠密图 -- 稠密图用邻接矩阵存储
//1. 初始化 邻接矩阵 -- 时间复杂度是o(n ^ 2)
//2. 输入数据
//3. 开始dijkstra
//4. 初始化距离数组,起点距离是0
//5. 循环n - 1次，每次找到最近的点t
//6. 找到最近的点t后，用点t来更新每一个的值
具体代码
#include<iostream>
#include<cstring>
using namespace std;
const int N = 510;
int g[N][N];
int d[N]; //存起点到每个点的最短距离
bool st[N]; //这个点是否已经被确定最短距离
int n,m;
long long res = 0;
int dijkstra()
{
//初始化距离
memset(d, 0x3f, sizeof d);
d[1] = 0;
for(int i=0; i < n-1; i++)
{
//找到没有确定最短路的点的距离最小的那一个
int t = -1;
for(int j=1; j <= n; j++)
if(!st[j] && (t== -1 || d[t] > d[j]))
t = j;
st[t] = true;
//用t更新其他点的距离,就是用1 到 t 到 j的距离,更新一下 1 到 j
for(int j=1; j <= n; j++)
d[j] = min(d[j], d[t] + g[t][j]);
}
if(d[n] == 0x3f3f3f3f) return -1;
return d[n];
}
int main()
{
scanf("%d%d", &n, &m);
//初始化
memset(g, 0x3f, sizeof g);
//输入数据
while(m -- )
{
int a,b,c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);
}
int t = dijkstra();
printf("%d", t);
return 0;
}
$\color{orange} {堆优化版Dijkstra} $
实现思路
// 堆优化， 这个dijkstra 的时间复杂度是 o(m * log n)
//这个是个稀疏图， 所以采用邻接表的方式存储
//1. 也是初始化
//2. 输入数据
//3. 开始dj
//4. 初始化距离数组
//5. 用优先队列来维护整个图priority_queue<PII, vector<PII>, greater<PII>> ,里面是pair型
//6. ver来代表这个节点的位置
//7. 开始遍历ver节点可以到的每一个节点
//8. 用j来存储这个节点图中的位置
//9. 如果d[j] > d[ver] + w[i] 就更新一下d[j]
//10. 最后再让{d[j], j}入列
具体代码
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
typedef pair<int ,int> PII;
const int N = 100010, M = N * 2;
int h[N], ne[M], e[M], idx, w[M];
int d[N], n, m;
bool st[N];
void add(int a,int b,int c)
{
w[idx] = c, e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int dijkstra()
{
memset(d, 0x3f, sizeof d);
d[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> q;
q.push({0, 1});
while(q.size())
{
auto t = q.top();
q.pop();
int ver = t.second;
if(st[ver]) continue;
st[ver] = true;
for(int i=h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if(d[j] > d[ver] + w[i]){
d[j] = d[ver] + w[i];
q.push({d[j], j});
}
}
}
if(d[n] == 0x3f3f3f3f) return -1;
else return d[n];
}
int main()
{
memset(h, -1, sizeof h);
scanf("%d%d", &n , &m);
while( m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d", dijkstra());
return 0;
}
++$\color{purple} {单源汇有负权边问题} $++
$\color{orange} {Bellman_ford算法} $
实现思路
//bellman_ford最短路，处理的是有负数边，而且限定次数的, 时间复杂度是o(nm)
//1. 这个里面用什么都可以，邻接表、邻接矩阵、都行，这里用的是结构体；
//2. 定义结构体,距离数组、备份数组, 输入数据
//3. 调用bellman_ford()
//4. 初始化距离数组
//5. 遍历k次,其中每次遍历m次，就是因为是m条边
//6. 每次都要备份一下d，因为怕串联
//7. 每次遍历中都需要取出来每个点
//8. 然后不断更新d[b] = min(d[b], backup[a] + w)
具体代码
#include<iostream>
#include<cstring>
using namespace std;
const int N = 510, M = 10010;
int n,m,k;
int d[N], backup[M];
struct Q{
int a,b,w;
}q[M];
int bellman_ford()
{
memset(d, 0x3f, sizeof d);
d[1] = 0;
for(int i=1; i <= k; i++)
{
memcpy(backup, d, sizeof d);
for(int j=1; j <= m ;j++)
{
int a = q[j].a, b = q[j].b, w = q[j].w;
d[b] = min(d[b], backup[a] + w);
}
}
if(d[n] > 0x3f3f3f3f / 2) return -0x3f3f3f3f;
return d[n];
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
for(int i=1; i <= m; i++)
scanf("%d%d%d", &q[i].a, &q[i].b, &q[i].w);
int t = bellman_ford();
if(t == -0x3f3f3f3f) printf("impossible");
else
printf("%d", t);
return 0;
}
$\color{orange} {SPFA算法} $
实现思路
SPFA也可以实现无负权边的
//这个是SPFA,是对于bellman_ford 的优化，用队列，时间复杂度是o(m)最坏是o(nm)
//这里的SPFA用邻接表存储的
//同样这个也是来算有负边的，但是一定不能有负环！！
//1. 定义邻接表、变量、队列、距离数组,bool st[]
//这个st呢是用来判断档当前这个点是否在队列中
//2. 初始化邻接表，输入数据
//3. 调用spfa算法 -- 跟dijkstra很像
//4. 队列维护， 基本的队列都得有
//5. 同样需要初始化距离数组，初始化队列
//6. 让st[t] 出列！
//7. 然后开始遍历从t开始的邻接表
//8. 然后让j来存储下一个点
//9. 后面就和dijkstra很像
//10. 如果j不在队列里面，就是j入列
具体代码
#include<iostream>
#include<cstring>
using namespace std;
const int N = 100010, M = N * 2;
int h[N], ne[M], e[M], w[M], idx;
int n,m;
int d[N], q[N];
bool st[N];
void add(int a,int b,int c)
{
w[idx] = c, e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int spfa()
{
memset(d, 0x3f, sizeof d);
d[1] = 0;
q[0] = 1;
st[1] = true;
int hh = 0, tt = 0;
while(hh <= tt)
{
int t = q[hh++];
st[t] = false;
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if(d[j] > d[t] + w[i]){
d[j] = d[t] + w[i];
if(!st[j])
{
st[j] = true;
q[++tt] = j;
}
}
}
}
if(d[n] > 0x3f3f3f3f / 2) return -0x3f3f3f3f;
else return d[n];
}
int main()
{
memset(h, -1,sizeof h);
scanf("%d%d", &n, &m);
while(m --)
{
int a,b,c;
scanf("%d%d%d", &a, &b, &c);
add(a, b ,c);
}
int t = spfa();
if(t == -0x3f3f3f3f) printf("impossible");
else printf("%d", t);
return 0;
}
++$\color{purple} {多源汇问题} $++
$\color{orange} {Floyd算法} $
实现思路
//用邻接矩阵存储的图
//解决的是多起点、多终点的最短路，时间复杂度是o(n^3)
//1. 定义邻接矩阵、初始化邻接矩阵
//2. 输入数据
//3. 调用floyd
//4. 核心操作d[i][j] = min(d[i][j], d[i][k] + d[k][j]); //外前内后
//5. 调用完以后，d[a][b]就是存的a到b的最短路
//6. 如果a到b不能生成最短路那么，还是无限大
具体代码
#include<iostream>
using namespace std;
const int N = 210;
int d[N][N];
int n,m,q;
int floyd()
{
for(int k=1; k <= n; k++)
for(int i=1; i <= n; i++)
for(int j=1; j <=n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]); // 外前内后
}
int main()
{
scanf("%d%d%d", &n, &m ,&q);
for(int i=1; i <= n; i++)
for(int j=1; j<=n; j++)
if(i == j) d[i][j] = 0;
else d[i][j] = 0x3f3f3f3f;
while(m -- )
{
int a,b,c;
scanf("%d%d%d", &a, &b, &c);
d[a][b] = min(d[a][b], c);
}
floyd();
while(q -- )
{
int a,b;
scanf("%d%d", &a, &b);
if(d[a][b] > 0x3f3f3f3f / 2) printf("impossible\n");
else printf("%d\n", d[a][b]);
}
return 0;
}
标签：idx,
int,
短路,
++,
st,
color,
include,
合集,
模板
From： https://www.cnblogs.com/wxzcch/p/17719239.html