单源最短路径(二)

最新推荐文章于 2024-10-16 00:00:43 发布
最新推荐文章于 2024-10-16 00:00:43 发布
阅读量296 收藏 10
点赞数 4
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73683197/article/details/139890516
版权

单源最短路的综合应用

(1) 新年好

第一眼，时间复杂度用朴素dijkstra肯定爆炸，只能堆优化版了

这题不是吃甜草的牛那道，每个亲戚可能都不在一条路径上，要找到分支的和，想到找到最短路中最远的一个亲戚，然后不断pre到他的前一个亲戚知道1，如果没有pre到说明不在一条路径上，需要找到没有pre到的点

[!WARNING]

这样想就偏离题意了

#include<bits/stdc++.h>

using namespace std;
typedef pair<int,int> PII;
int n,m;
const int N=1e5+10;
int h[N],e[N],ne[N],w[N],idx;
int st[N],d[N],pre[N];
int vis[5];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

void dijkstra(){
  memset(d,0x3f,sizeof d);
  
  priority_queue<PII,vector<PII>,greater<PII> > q;
  q.push({0,1});
  d[1]=0;
  
  while(q.size()){
    auto t=q.top();
    q.pop();
    
    int ver=t.second,dist=t.first;
    if(st[ver]) continue;
    st[ver]=1;
    
    for(int i=h[ver];i!=-1;i=ne[i]){
      int j=e[i];
      if(d[j]>dist+w[i]){
        d[j]=dist+w[i];
        pre[j]=ver;
        q.push({d[j],j});
        cout<<ver<<' '<<j<<' '<<d[j]<<endl;
      }
    }
  }
}

signed main(){
  cin>>n>>m;
  int a[5];
  memset(h,-1,sizeof h);
  for(int i=0;i<5;i++) cin>>a[i];
  for(int i=0;i<m;i++){
    int x,y,z;
    cin>>x>>y>>z;
    add(x,y,z);
    add(y,x,z);
  }
  dijkstra();
  int ans=0;
  int end=1;
  //vis[end]=1;
  for(int i=0;i<5;i++){
    int maxn=a[i];
    for(int j=0;j<5;j++){
      if(!vis[a[j]]&&d[a[j]]>d[maxn]){
        maxn=a[j];
      }
    }
    
    cout<<maxn<<' '<<d[maxn]<<endl;
    if(!vis[maxn]){
      end=maxn;
      ans+=d[end];
      //vis[maxn]=1;
    } 
    while(end!=1&&!vis[end]){
      //cout<<end<<' ';
      vis[end]=1;
      end=pre[end]; 
    }
    //cout<<endl;
  }
  
  
  cout<<ans<<endl;
  return 0;
}

仔细分析代码和样例发现，这题和信使(最远最短路)以及牛吃甜草(选一个点到各个点最短距离只和最小)不一样

重新捋一遍思路，发现需要找到一个最优访问亲戚的顺序，那就需要对亲戚的访问顺序做一遍排列

#include<bits/stdc++.h>

using namespace std;
typedef pair<int,int> PII;
int n,m;
//是双向的，M别开小了
const int M=2e5+10,N=5e4+10,INF=0x3f3f3f3f;
int h[M],e[M],ne[M],w[M],idx;
int d[6][N],st[N],vis[N];
int a[6];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int dfs(int u,int start,int distance){
  if(u==6){
    return distance;
  }
  int res=INF;
  for(int i=1;i<=5;i++){
    if(!vis[i]){
      int next=a[i];
      vis[i]=1;
      res=min(res,dfs(u+1,i,distance+d[start][next]));
      vis[i]=0;
    }
  }
  return res;
}

//这里d[]是局部一位数组
void dijkstra(int start,int d[]){
  
  memset(st,0,sizeof st);
  memset(d,0x3f,N*4);
  
  priority_queue<PII,vector<PII>,greater<PII> > q;
  
  q.push({0,start});
  d[start]=0;
  
  while(q.size()){
    auto t=q.top();
    q.pop();
    
    int ver = t.second,dist=t.first;
    
    if(st[ver]) continue;
    st[ver]=1;
    
    for(int i=h[ver];i!=-1;i=ne[i]){
      int j=e[i];
      if(d[j]>dist+w[i]){
        d[j]=dist+w[i];
        q.push({d[j],j});
      }
    }
  }
}

signed main(){
  cin>>n>>m;
  
  memset(h,-1,sizeof h);
  a[0]=1;
  for(int i=1;i<=5;i++) cin>>a[i];
  
  for(int i=0;i<m;i++){
    int x,y,z;
    cin>>x>>y>>z;
    add(x,y,z);
    add(y,x,z);
  }
  for(int i=0;i<6;i++) dijkstra(a[i],d[i]);
  
  cout<<dfs(1,0,0)<<endl;
  return 0;
}
(2) 通信线路

“指定路径上（1—>N）不超过 𝐾 条电缆”有点bellman_ford的味道 （✅）

“最贵” 先把最难走的路径（1—>N）给公司，然后从剩下的路径中选（❌）

但其实不是bellman_ford算法，因为不是要求在k内抵达N

#include<bits/stdc++.h>

using namespace std;
int n,p,k;
const int N=1e3+10,M=2e4+10;
int h[M],e[M],ne[M],w[M],idx,st[N],d[N];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int check(int mid){
  memset(d,0x3f,sizeof d);
  memset(st,0,sizeof st);
  deque<int> q;
  
  q.push_back(1);
  d[1]=0;
  
  while(q.size()){
    int t=q.front();
    q.pop_front();
    
    if(st[t]) continue;
    st[t]=1;
    
    for(int i=h[t];i!=-1;i=ne[i]){
      int j=e[i],v=w[i]>mid;
      if(d[j]>d[t]+v){
        d[j]=d[t]+v;
        if(!v) q.push_front(j);
        else {
          q.push_back(j);
        }
      }
    }
  }
  return d[n]<=k;
}


signed main(){
  cin>>n>>p>>k;
  memset(h,-1,sizeof h);
  for(int i=0;i<p;i++){
    int x,y,z;
    cin>>x>>y>>z;
    add(x,y,z);
    add(y,x,z);
  }
 	
  int l=0,r=1e6+1;
  while(l<r){
    int mid=(l+r)>>1;
    if(check(mid)) r=mid;
    else l=mid+1;
  }
  if(r==1e6+1) r=-1;
  cout<<r<<endl;
  return 0;
}
(3)道路与航线

初看题目，有负边权，那么先不考虑dijkstra。

有两条道路，一种是是可以为负数的航线，一种是只有正数的道路。

“保证如果有一条航线可以从 Ai𝐴𝑖 到 Bi𝐵𝑖，那么保证不可能通过一些道路和航线从 𝐵𝑖 回到 𝐴𝑖”这句话应该是保证数据不可能出现负环。

感觉只能spfa

手搓一个spfa,第一次做这个题，没有ac

#include<bits/stdc++.h>

using namespace std;
int t,r,p,s;
const int N=2e5+10,M=3e5+10,INF=0x3f3f3f3f;
int h[M],e[M],ne[M],w[M],idx;
int st[N],d[N];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

void spfa(){
  memset(d,0x3f,sizeof d);
  
  queue<int> q;
  d[s]=0;
  q.push(s);
  
  while(q.size()){
    int t=q.front();
    q.pop();
    
    st[t]=1;
    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]){
          q.push(j);
        }
      }
    }
  }
}

signed main(){
  cin>>t>>r>>p>>s;
  memset(h,-1,sizeof h);
  for(int i=0;i<r;i++){
    int x,y,z;
    cin>>x>>y>>z;
    add(x,y,z);
    add(y,x,z);
  }
  
  for(int i=0;i<p;i++){
    int x,y,z;
    cin>>x>>y>>z;
    add(x,y,z);
  }
  spfa();
  for(int i=1;i<=t;i++){
    if(d[i]>=INF/2){
      puts("NO PATH");
    }
    else cout<<d[i]<<endl;
  }

  return 0;
}

ac代码

道路连起来的团看成一个拓扑点，在点内做dijkstra，同时完成拓扑。

求连通块这部分不是很熟悉

连通块代码练习

#include<bits/stdc++.h>

using namespace std;
const int N=1e2+10;
int h[N],e[N],w[N],ne[N],idx;
int bcnt,id[N];
vector<int> block[N];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u){
  //把相邻的点加入同一连通块中
  block[bcnt].push_back(u);
  //记录每个点所在连通块
  id[u]=bcnt;
  
  for(int i=h[u];i!=-1;i=ne[i]){
    int j=e[i];
    if(!id[j]){
      dfs(j);
    }
  }
}

signed main(){
  int n,m;
  cin>>n>>m;
  memset(h,-1,sizeof h);
  for(int i=0;i<m;i++){
    int a,b,c;
    cin>>a>>b>>c;
    add(a,b,c);
  }
  for(int i=1;i<=n;i++){
    if(!id[i]){
      bcnt++;
      dfs(i);
      
    }
  }
  cout<<bcnt<<endl;
  for(int i=1;i<=bcnt;i++){
      cout<<i<<endl;
    for(int j=0;j<block[i].size();j++){
      cout<<block[i][j]<<' ';
    }
    cout<<endl;
  }
	return 0;
}

测试

输入：

6 4
1 3 2 
3 5 2
2 4 1
2 6 1

输出：

2
1
1 3 5 
2
2 6 4 

#include<bits/stdc++.h>

using namespace std;
int t,r,p,s;
//M别开小了
const int N=1e5+10,M=2e5+10,INF=0x3f3f3f3f;
typedef pair<int,int> PII;
int id[N],bcnt,din[N];
vector<int> block[N];
queue<int> q;
int h[M],e[M],w[M],ne[M],idx;
int st[N],d[N];

void add(int a,int b,int c){
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}


//用一个全局变量bcnt记录连通块个数，通过在main函数里判断是否已经被记录来自增
void dfs(int u){
  block[bcnt].push_back(u);
  id[u]=bcnt;
  
  for(int i=h[u];i!=-1;i=ne[i]){
    int j=e[i];
    if(!id[j]){
      dfs(j);
    }
  }
}

void dijkstra(int bid){
  
  priority_queue<PII,vector<PII>, greater<PII> > heap;
  
  for(int i=0;i<block[bid].size();i++){
    int j=block[bid][i];
    heap.push({d[j],j});
  }
  
  while(heap.size()){
    auto t=heap.top();
    heap.pop();
    
    int ver=t.second,dist=t.first;
    
    if(st[ver]) continue;
    st[ver]=1;
    for(int i=h[ver];i!=-1;i=ne[i]){
      int j=e[i];
      if(id[ver]!=id[j]&&--din[id[j]]==0) q.push(id[j]);
      if(d[j]>dist+w[i]){
        d[j]=dist+w[i];
        if(id[ver]==id[j])
        	heap.push({d[j],j});
      }
    }
  }
  
}

void topesort(){
  memset(d,0x3f,sizeof d);
  d[s]=0;
  //把入度为零的点加入队列中
 	for(int i=1;i<=bcnt;i++){
    if(din[i]==0){
      q.push(i);
    }
    while(q.size()){
      int t = q.front();
      q.pop();
      dijkstra(t);
    }
  }
}

signed main(){
  cin>>t>>r>>p>>s;
  memset(h,-1,sizeof h);
  for(int i=0;i<r;i++){
    int a,b,c;
    cin>>a>>b>>c;
    add(a,b,c);
    add(b,a,c);
  }
  
  for(int i=1;i<=t;i++){
    if(!id[i]){
      bcnt++;
      dfs(i);
    }
  }
  
  for(int i=0;i<p;i++){
    int a,b,c;
    cin>>a>>b>>c;
    add(a,b,c);
    din[id[b]]++;
  }
  topesort();
  for(int i=1;i<=t;i++){
    if(d[i]>=INF/2) puts("NO PATH");
    else cout<<d[i]<<endl;
  }
  return 0;
}
(4) 最优贸易

最短路计数了解一下

fhq-treap了解一下

反向建图懂了

动态规划和最短路的交集是拓扑关系

不能用dijkstra是因为最小价格（最大价格）是在一条边的两端取，会出现后出现的点可以更新前面的点的情况，所以不能用基于贪心的Dijkstra算法

#include<bits/stdc++.h>

using namespace std;
int n,m;
const int N=1e5+10,M=1e6+10;
int hs[N],ht[N],e[M],ne[M],idx;
int st[N],dmax[N],dmin[N],w[N];

void add(int *h,int a,int b){
  e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void spfa(int *d,int start,int *h,bool flag){
  queue<int> q;
  memset(st,0,sizeof st);
  if(flag){
    memset(dmin,0x3f,sizeof dmin);  //引用可以直接对原数组操作，不能对应用用sizeof
  }
  d[start]=w[start];
  q.push(start);
  
  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(flag&&d[j]>min(d[t],w[j])||!flag&&d[j]<max(d[t],w[j])){
        if(flag){
          d[j]=min(d[j],w[j]);
        }
        else{
          d[j]=max(d[t],w[j]);
        }
        if(!st[j]){
          q.push(j);
          st[j]=1;
        }
      }
    }
  }
}

signed main(){
  cin>>n>>m;
  memset(hs,-1,sizeof hs);
  memset(ht,-1,sizeof ht);
  for(int i=1;i<=n;i++) cin>>w[i];
  for(int i=0;i<m;i++){
    int a,b,c;
    cin>>a>>b>>c;
    add(hs,a,b);add(ht,b,a);
    if(c==2){
      add(hs,b,a);
      add(ht,a,b);
    }
  }
  spfa(dmin,1,hs,1);
  spfa(dmax,n,ht,0);
  
  int res=0;
  for(int i=1;i<=n;i++){
    res=max(dmax[i]-dmin[i],res);
  }
  
  cout<<res<<endl;
  return 0;
}
wlwhonest
关注
最短路径问题——单源最短路径问题
m0_56945100的博客
08-24 432
根据结点的拓扑排序次序来对有向无环图进行边的松弛操作（由于无环，则负环路肯定不存在）。每次松弛从当前结点出发的所有边。伪代码：邻接表存储：；邻接矩阵存储：。
JAVA编程求单源最短路径_【算法】单源最短路径——dijkstra算法
weixin_28878311的博客
02-26 1655
一,概念单源最短路径给定一个带权有向图G=(V,E)，其中每条边的权是一个实数。另外，还给定V中的一个顶点，称为源。要计算从源到其他所有各顶点的最短路径长度。这里的长度就是指路上各边权之和。这个问题通常称为单源最短路径问题。dijkstra算法简介迪杰斯特拉算法(Dijkstra),是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心...
单源最短路径问题
a18173352623的博客
12-11 832
给定一个带权有向图G=(V,E)，其中每条边的权是非负数。给定V中的一个顶点a，成为源。现在要计算从源到所有其他个顶点的最短路径长度，这里路径长度指的是各边权之和。这个问题通常被称作单源最短路径问题。如下图所示，每一边都有一非负权值。求图G中从源点a到t的最短路径。 因为是求单源问题，可以使用四种方法进行求解。 算法的基本思路： 分支界限法主要思想在于，将一个问题分成树状，每次选择最优的一个枝叶。比如单源问题便是每次选择最短路径作为基点去不断更新其他路径。 如何书写代码：朴素版的Dijkstra
单源最短路径算法
「止于纸扇」的博客
08-09 306
详解图论有关模板
Dijkstra算法——单源最短路径查找
qq_61500888的博客
10-29 7846
单源最短路径的查找——Dijkstra 算法
图详解第四篇：单源最短路径--迪杰斯特拉算法(Dijkstra)算法
m0_70980326的博客
10-17 5653
单源最短路径--Dijkstra算法
Dijkstra-单源最短路径算法
冲出仁川，走出马德里，故事还会再继续
03-14 1675
Dijkstra算法用来计算一个点到其他所有点的最短路径的算法，是一种单源最短路径算法。也就是说，只能计算起点只有一个的情况。算法的时间复杂度是On3O(n^3)On3，它不能处理存在负边权的情况。算法描述：设起点为s,dis[v]表示从s到v的最短路径长度disv∞v≠s;i
Dijkstra算法：求单源最短路径
m0_68805093的博客
08-17 868
Dijkstra算法的具体实现
单源最短路径分析
qq_45923860的博客
12-05 2460
单源最短路径问题是指计算从特定的源顶点到每一个顶点的最短路径，或则对称的，从每一个顶点到特定的目的顶点的最短路径。本文从图的基本数据结构入手，讲解有向无环图与一般有向图（带正环或负环）的求解，并从动态规划方面推出经典的Bellman_Ford算法，并对于负圈检测的理论基础也给与分析，而后观察迭代结果，提出算法中存在的两类冗余情况，并对其修改以提高效率；并将去除冗余后的Bellman_Ford推广为Dijkstra算法，并借此讲解如何由动态规划设计贪心算法！
单源最短路径贪心算法 c语言,单源最短路径_贪心算法
weixin_35632257的博客
05-23 585
public class TheShortestWay{static int MAX_SIZE=6;public static void dijkstra(int v,float[][]a,float[]dist,int[]prev){int n=dist.length-1;if(v<1||v>n)return;boolean []s=new boolean[n+1];for(int ...
分支限界法求解单源最短路径.zip
12-21
在本案例中，我们关注的是如何利用分支限界法求解单源最短路径问题。单源最短路径问题是从一个指定的起点到图中所有其他顶点的最短路径问题，这个问题在图论和计算机科学中有广泛的应用，例如网络路由优化、物流配送...
基于贪心法求解单源最短路径问题.docx
06-03
"基于贪心法求解单源最短路径问题" 本资源是关于基于贪心法求解单源最短路径问题的实验报告，包括实验内容、算法设计、算法描述、算法正确性证明、算法分析、算法实现与测试等部分。 实验目的：理解贪心法的核心...
java实现单源最短路径
08-26
"java实现单源最短路径" java实现单源最短路径是使用java语言实现的单源最短路径算法。该算法使用Dijkstra算法，采用邻接表表示图，通过构建邻接表来实现单源最短路径的计算。 单源最短路径算法是一种常用的图算法...
动态规划求单源最短路径.doc
11-23
算法设计与分析课内实验——动态规划求单源最短路径。文档很齐全，包括算法分析过程和源代码（java语言eclipse环境）
python实现有向图单源最短路径迪杰斯特拉 算法
09-27
迪杰斯特拉（Dijkstra）算法是一种用于寻找有向图中单源最短路径的经典算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在1956年提出。在这个算法中，我们从一个源节点开始，逐步扩展最短路径到其他节点，直到到达所有...
【算法】深入了解 CRC 校验码的计算过程
最新发布
qq_20623849的博客
10-16 528
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【算法】双指针
2303_80828380的博客
10-13 771
力扣oj题之双指针算法
力扣10.13
qq_40052678的博客
10-13 436
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【进阶OpenCV】 （14）-- 人脸识别 -- LBPH 算法
m0_74896766的博客
10-15 1076
本篇介绍了如何通过创建LBPH的人脸识别器来进行人脸识别。
分支限界法求解单源最短路径
"该资源是一份关于分支限界法用于解决单源最短路径问题的实验报告，由贵州大学计算机科学与技术学院软件工程专业的学生宋君华完成，指导教师为刘长云。实验环境为Window7操作系统和myeclipes编译器。实验目的是理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值