【最短路径】
目录
- 知识框架
- No.1 MP[ N ][N】版本Dijs最短路径模板给出路径让判断是否可行
-
- 题目来源：PTA-L2-036 网红点打卡攻略
- No.2 floyd
-
- 题目来源：PTA-L2-044 大众情人
- No.1 完全体求各种东西的dijs
-
- 题目来源：PTA-L2-001 紧急救援
- 题目来源：PTA-L3-005 垃圾箱分布
- 题目来源：PTA-L3-007 天梯地图
- 题目来源：PTA-L3-011 直捣黄龙
- 题目来源：RoboCom-7-3 打怪升级
- No.2 dijkstra
-
- 题目来源：Acwing-4275-dijkstra序列
- 题目来源：PTA-L3-028 森森旅游
- No.4 牛客网-最短路径
-
- Bellman-Ford算法
- Dijkstra算法/Dijkstra + 优先队列的优化
- floyd-Warshall算法
- SPFA
- NC14369：最短路：很直接
- NC15522：武 ：很直接
- NC15549：小木乃伊到我家
- NOI1997：最优乘车
- NC22947：香甜的黄油
- NC17511：公交线路
- NC14292：Travel
知识框架
No.1 MP[ N ][N】版本Dijs最短路径模板给出路径让判断是否可行
题目来源：PTA-L2-036 网红点打卡攻略
题目描述：
题目思路：
题目代码：
//注意使用int 而不是 double ，注意出现flag=1的 三 个条件
//对于N要进行适应性的更改，对于字段错误
// // if(num==inf || vis[ans[i]]==1 ||x!=n ){
#includeNo.2 floyd
题目来源：PTA-L2-044 大众情人
题目描述：
题目思路：
题目代码：
//对于 每个 结点 找 异性且 距离 最远的结点，得到该 数值；存储，然后找到 最小的；
// 先弗洛伊德，然后对于每个 都遍历得到数值；
//对于N要进行适应性的更改，对于字段错误
#includeNo.1 完全体求各种东西的dijs
题目来源：PTA-L2-001 紧急救援
题目描述：
题目思路：
题目代码：
//这道题给的教训就是：：#define N 要恰到好处不能太大，也不能太小。。切记
//对于N要进行适应性的更改，对于字段错误
#include题目来源：PTA-L3-005 垃圾箱分布
题目描述：
题目思路：
题目代码：
//这个注意点时最短距离最远加上平均距离，这两个；；
//但是最后4分不知道为啥怎么办？好像是精度的问题：
//对于N要进行适应性的更改，对于字段错误
#include题目来源：PTA-L3-007 天梯地图
题目描述：
题目思路：
题目代码：
//对于N要进行适应性的更改，对于字段错误
#include题目来源：PTA-L3-011 直捣黄龙
题目描述：
题目思路：
题目代码：
#include题目来源：RoboCom-7-3 打怪升级
题目描述：
题目思路：
题目部分解释：“即空降到地图中的某个堡垒，使得玩家从这个空降点出发，到攻下最难攻克（即耗费能量最多）的那个堡垒所需要的能量最小；“
上面那个的意思是对于每一个点都dij一下，然后记录该点到其它点到底是哪一个消耗最大，同理得到n个消耗最大，然后找到消耗最大里面的最小的；也是相当于flod然后对于每个点找到最大的，再进行比较找最小的；；
题目代码：
#include No.2 dijkstra
题目来源：Acwing-4275-dijkstra序列
题目描述：
题目思路：
题目代码：
//对于N要进行适应性的更改，对于字段错误
#include题目来源：PTA-L3-028 森森旅游
题目描述：
题目思路：
大致思路就是找个点 q，从开始到q，以及结尾到q的最短消费路径。
题目代码：
//又是一分没有的代码啊啊啊啊
#include No.4 牛客网-最短路径
最短路算法详解_weixin_34018202的博客-CSDN博客
1：两种存储方式：因为邻接表没有 前向星可观，所以 ：邻接矩阵+前向星
NC14501：大吉大利，晚上吃鸡：最短路+动态规划
Bellman-Ford算法
Dijkstra算法/Dijkstra + 优先队列的优化
NC20131：飞行路线
//这个k层免费 不是简单的先找到最短，然后去掉k个最大的；
floyd-Warshall算法
SPFA
1：链式前向星：
其中edge[ ] .to表示第i条边的终点, edge[i] .next表示与第i条边同起点的下一条边的存储位置,edge[i] .w为边权值.
另外还有一个数组head[ ],它是用来表示以i为起点的第一条边存储的位置,实际上你会发现这里的第一条边存储的位置其实
在以i为起点的所有边的最后输入的那个编号．
head[]数组一般初始化为-1,对于加边的add函数是这样的:
下面是对链式前向星的讲解：注意那个 head[u] = cnt++;//更新以u为起点上一条边的编号 是先赋值，再 累加的；
链式前向星–最通俗易懂的讲解_sugarbliss的博客-CSDN博客_链式前向星
NC14369：最短路：很直接
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 100100
int n,m,k,g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int mp[2000+1][20000+1];
int vis[N];
int dist[N];
int to[N],w[N],head[N]={-1},ne[N],idx=0;
//vis数组标记了节点v是否在Q中
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x]; //这条边的上一条边
head[x]=idx++; // 这个点的最后一条边为： idx表示边
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[1]=0;
vis[1]=1;
queueq;
q.push(1);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
//遍历以x为起点的所有的边；to
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>n>>m;
while(m--){
cin>>x>>y>>z;
add(x,y,z);
}
spfa();
for(int i=2;i<=n;i++){
cout< NC15522：武 ：很直接
//注意 链式前向星的 如果是无向图 需要两次 add 且 数据的N边数要乘以2
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 100010
int n,m,k,g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N];
int to[N*2],head[N*2]={-1},ne[N*2],w[N*2];//这个因为是无向图；双向
int idx=0;
int p;
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>n>>p>>k;
for(int i=1;i<=n-1 ;i++){
cin>>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
spfa();
sort(dist+1,dist+1+n);
cout< NC15549：小木乃伊到我家
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 200010
int n,m,k,g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N];
int to[N*2],head[N*2]={-1},ne[N*2],w[N*2];//这个因为是无向图；双向
int idx=0;
int p;
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>n>>m;
p=1;//出发点
while(m--){
cin>>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
spfa();
if(dist[n]==inf)cout<<"qwb baka"< NOI1997：最优乘车
对于：stringstream ss 等的用法；；
int main(){
string s = "1 23 # 4";
stringstream ss;
ss<>s){
cout<(s);
cout< //第一种方法：用bfs 函数类似;
//第二种类比距离：该条路线距离为0 换乘一次能达到的为距离为1 的点；所以最终结果要-1；下面用的是这个
// 类比化距离；；
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 200010
int n,m,k,g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N],stop[N];
int to[N*2],head[N*2]={-1},ne[N*2],w[N*2];//这个因为是无向图；双向
int idx=0;
int p;//开始的地方：
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>m>>n;
getchar();
while(m--){
getline(cin,str);
stringstream ssin(str);
int cnt=0;
while(ssin>>p)stop[cnt++]=p;
for(int i=0;i NC22947：香甜的黄油
//问题是：图中已经确定的几点到 图中某一点的最短距离；
// 即 dist[c1]+dist[c2]+...+dist[cn]
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 200010
int n,m,k,c[N],g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N],stop[N];
int to[N*2],head[N*2]={-1},ne[N*2],w[N*2];//这个因为是无向图；双向
int idx=0;
int p;//开始的地方：
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
int res=inf;
cin>>d>>n>>m;
for(int i=1;i<=d;i++){
cin>>c[i];
}
while(m--){
cin>>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
for(int i=1;i<=n;i++){
//以i为起点
p=i;
spfa();
int num=0;
for(int j=1;j<=d;j++){
num+=dist[c[j]];
}
res=min(res,num);
}
cout< NC17511：公交线路
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 200010
int n,m,k,c[N],g,s,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N],stop[N];
int to[N*2],head[N*2]={-1},ne[N*2],w[N*2];//这个因为是无向图；双向
int idx=0;
int p;//开始的地方：
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>n>>m>>s>>d;
p=s;
while(m--){
cin>>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
spfa();
if(dist[d]==inf)cout<<0< NC14292：Travel
//对于N要进行适应性的更改，对于字段错误
#include
using namespace std;
#define inf 0x3f3f3f3f
#define N 200010
int n,m,k,q,g,d;
int x,y,z;
char ch;
string str;
vectorv[N];
int dist[N],vis[N];
int to[N*5],head[N*5]={-1},ne[N*5],w[N*5];//这个因为是无向图；双向
int idx=0;
int p;
void add(int x,int y,int z){
to[idx]=y;
w[idx]=z;
ne[idx]=head[x];
head[x]=idx++;
}
void spfa(){
memset(dist,inf,sizeof(dist));
memset(vis,0,sizeof(vis));
dist[p]=0;
vis[p]=1;
queueq;
q.push(p);
while(q.size()){
x=q.front();
q.pop();
vis[x]=0;
for(int j=head[x];j!=-1;j=ne[j]){
int i=to[j];
if(dist[i]>dist[x]+w[j]){
dist[i]=dist[x]+w[j];
if(vis[i]==0){
q.push(i);
vis[i]=1;
}
}
}
}
}
int main() {
memset(head,-1,sizeof(head));
cin>>n>>m;
for(int i=1;i<=n;i++){
if(i==n){
cin>>x;
add(i,1,x);
add(1,i,x);
}else{
cin>>x;
add(i,i+1,x);
add(i+1,i,x);
}
}
for(int i=1;i<=m;i++){
cin>>x>>y>>z;
if(x==y)continue;
add(x,y,z);
add(y,x,z);
}
cin>>q;
while(q--){
cin>>x>>y;
p=x;
spfa();
cout<
#define ll long long
#define PII pair
using namespace std;
const int N=52501+10,M=22;
ll n,m,q,x,y;
ll p[N],dist[N][M<<1];
int d[N],h[N],tot,door[M<<1];
bool st[N];
struct node{
int to,nxt,k;
}e[N*2];
void add(int u,int v,int w){
e[++tot].to=v;
e[tot].nxt=h[u];
e[tot].k=w;
h[u]=tot;
}
void dijkstra(int x){
int s=door[x];
dist[s][x]=0;
priority_queue,greater> heap;
heap.push({s,0});
while(heap.size()){
int u=heap.top().first;
heap.pop();
for(int i=h[u];i!=-1;i=e[i].nxt){
int v=e[i].to;
if(dist[v][x]>dist[u][x]+e[i].k){
dist[v][x]=dist[u][x]+e[i].k;
heap.push({v,dist[v][x]});
}
}
}
}
int main(){
cin>>n>>m;
memset(h,-1,sizeof h);
memset(dist,0x3f,sizeof dist);
for(int i=1;i<=n;++i) cin>>d[i],p[i]=p[i-1]+d[i];
for(int i=1;i>u>>v>>w;
add(u,v,w),add(v,u,w);
door[++nd]=u,door[++nd]=v;
}
sort(door+1,door+1+nd);
nd=unique(door+1,door+1+nd)-(door+1);
for(int i=1;i<=nd;++i)
dijkstra(i);
cin>>q;
while(q--){
cin>>x>>y;
ll len=abs(p[x-1]-p[y-1]);
ll ans=min(len,p[n]-len);
for(int i=1;i<=nd;++i)
ans=min(ans,dist[x][i]+dist[y][i]);
cout<