标签：cnt 转载 const 短路 单源 gg include head dis
一、求正权图的单源最短路
对于求正权图的单源最短路问题，我们一般使用Dijistra算法求解
Dijistra算法
Dijistra算法的基本思想是贪心。
我们可以先把所有点的距离设为一个无穷大的数，然后将起始点的\(dis\)设为一，每次找一个\(dis\)最小并且没有被标记过的点，然后将这个点打上标记，查询这个边所有的出边，设原点为\(i\)，这条出边对应的点为\(j\)，这条边的边权为\(v\)，则当\(dis_i+v<dis_j\)时更新\(dis_j\)的值，当所有边都被标记时，从这个点到其它点的最短路就都求出来了。
代码实现-时间复杂度\(O(n^2)\)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<array>
#include<bitset>
using namespace std;
using gg=long long;
array<gg,200010> nxt,to,val;
array<gg,100010> head,dis;
bitset<100010> fl;
gg cnt=0;
void add(const gg &x,const gg &y,const gg &v) //链式前向星存图
{
cnt++;
nxt[cnt]=head[x];
head[x]=cnt;
to[cnt]=y;
val[cnt]=v;
return;
}
int main()
{
gg n,m,x,y,v; //n个点，m条边
cin>>n>>m;
while(m--) //建图
{
cin>>x>>y>>v;
add(x,y,v);
}
for(gg i=1;i<=n+1;i++) dis[i]=114514114514;
dis[1]=0;
while(1)
{
gg x=n+1;
for(gg i=1;i<=n;i++)
{
if(dis[x]>dis[i]&&fl[i]==false)
{
x=i;
}
}
if(x==n+1) break;
fl[x]=true;
for(gg i=head[x];i;i=nxt[i])
{
if(dis[x]+val[i]<dis[to[i]])
{
dis[to[i]]=dis[x]+val[i];
}
}
}
for(gg i=1;i<=n;i++)
{
cout<<dis[i]<<'\n';
}
return 0;
}
这时候，细心的同学可能已经发现了嗷——这个找dis最小值的操作完全可以使用STL中的优先队列实现
改进后代码-时间复杂度\(O(nlogn)\)
#include<iostream>
#include<array>
#include<algorithm>
#include<cmath>
#include<vector>
#include<bitset>
#include<queue>
#include<utility>
using namespace std;
using gg=long long;
array<gg,400010> nxt,to,val;
array<gg,200010> head,dis;
bitset<200010> fl;
priority_queue<pair<gg,gg>,vector<pair<gg,gg>>,greater<pair<gg,gg>>> list;
gg cnt=0;
void add(const gg &fr,const gg &t,const gg &v)
{
cnt++;
to[cnt]=t;
nxt[cnt]=head[fr];
head[fr]=cnt;
val[cnt]=v;
return;
}
int main()
{
gg n,m,x,z,y,s;
cin>>n>>m>>s;
for(gg i=1;i<=m;i++)
{
cin>>x>>y>>z;
add(x,y,z);
}
for(gg i=1;i<=n;i++)
{
dis[i]=114514114514;
}
dis[s]=0;
list.push(make_pair(0,s));
while(!list.empty())
{
gg poi=list.top().second;
list.pop();
if(fl[poi]) continue;
fl[poi]=true;
for(gg i=head[poi];i;i=nxt[i])
{
if(dis[poi]+val[i]<dis[to[i]])
{
dis[to[i]]=dis[poi]+val[i];
list.push(make_pair(dis[to[i]],to[i]));
}
}
}
for(gg i=1;i<=n;i++)
{
cout<<dis[i]<<' ';
}
cout<<'\n';
return 0;
}
Dijistra练习题
二、求带负边的单源最短路
如果图中存在负边，Dijistra算法就不能用了，因为其中的判断会不断加上这条负边从而出现更小的数，这个时候，就是著名的SPFA算法出场的时候了！
SPFA算法
SPFA算法维护一个队列，首先把起点处的\(dis\)更新为0，其余初始化为无穷大，并将起点加入队列中，打上标记。每次取出队头的一个点，并把这个点的标记消除，扫描这个点的所有出边，设原点为\(i\)，这条出边对应的点为\(j\)，这条边的边权为\(v\)，则当\(dis_i+v<dis_j\)时更新\(dis_j\)的值并查看点j是否在队列中，如果不在就将点j加入队列，并打上标记。当队列为空时，就求出了原点到各个点的最短路。
注意:SPFA在应对随机数据时为\(O(kn)\)的时间复杂度，其中\(k\)是一个较小的数，但当数据为特殊构造时，此算法的时间复杂度会被卡到\(O(nm)\)，因此使用此算法时应三思而后行
代码实现
#include<iostream>
#include<algorithm>
#include<cmath>
#include<array>
#include<queue>
#include<bitset>
using namespace std;
using gg=long long;
array<gg,200010> nxt,to,val;
array<gg,100010> head,dis;
bitset<100010> fl;
queue<gg> list;
gg cnt=0;
void add(const gg &x,const gg &y,const gg &v) //链式前向星存图
{
cnt++;
nxt[cnt]=head[x];
head[x]=cnt;
to[cnt]=y;
val[cnt]=v;
return;
}
int main()
{
gg n,m,x,y,v; //n个点，m条边
cin>>n>>m;
while(m--) //建图
{
cin>>x>>y>>v;
add(x,y,v);
}
for(gg i=1;i<=n+1;i++) dis[i]=114514114514; //初始化
dis[1]=0;
list.push(1);
fl[1]=true;
while(!list.empty()) //SPFA
{
gg p=list.front();
list.pop();
fl[p]=false;
for(gg i=head[p];i;i=nxt[i])
{
if(dis[p]+val[i]<dis[to[i]])
{
dis[to[i]]=dis[p]+val[i];
if(!fl[to[i]]) list.push(to[i]),fl[to[i]]=true;
}
}
}
for(gg i=1;i<=n;i++)
{
cout<<dis[i]<<'\n';
}
return 0;
}
感谢阅读！
标签：cnt,转载,const,短路,单源,gg,include,head,dis 来源： https://www.cnblogs.com/firesonz/p/16519628.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。