最短路算法

Dijkstra堆优化

dijkstra的原理/流程?
dijkstradijkstra本质上的思想是贪心,它只适用于不含负权边的图.
我们把点分成两类,一类是已经确定最短路径的点,称为"白点",另一类是未确定最短路径的点,称为"蓝点"
dijkstradijkstra的流程如下::
1.1. 初始化dis[start] = 0,dis[start]=0,其余节点的disdis值为无穷大.
2.2. 找一个disdis值最小的蓝点x,x,把节点xx变成白点.
3.3. 遍历xx的所有出边(x,y,z),(x,y,z),若dis[y] > dis[x] + z,dis[y]>dis[x]+z,则令dis[y] = dis[x] + zdis[y]=dis[x]+z
4.4. 重复2,32,3两步,直到所有点都成为白点…
时间复杂度为O(n^2)O(n
2
)
dijkstradijkstra为什么是正确的
当所有边长都是非负数的时候,全局最小值不可能再被其他节点更新.所以在第22步中找出的蓝点xx必然满足:dis[x]:dis[x]已经是起点到xx的最短路径…我们不断选择全局最小值进行标记和拓展,最终可以得到起点到每个节点的最短路径的长度

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define inf 2147483647
int n,m,s,a,b,c;
struct node
{
    int next,to;
    int w;
}edge[5000001];
struct fow{
    int pt,cost;
};
int top=0;
int dis[5000001],vis[5000001],head[5000001];
struct cmp{
    bool operator()(fow a,fow b){
        return a.cost>b.cost;//important 
    }
};
void add(int from,int to,int w) 
{ 
  edge[++top].next=head[from];
  edge[top].to=to;
  edge[top].w=w;
  head[from]=top; 
}
void dijkstra(){
    priority_queue<fow,vector<fow>,cmp> q;
    fow r;
    r.pt=s;
    r.cost=0;
    dis[s]=0;
    q.push(r);
    while(!q.empty()){
        fow nt=q.top();
        q.pop();
        int now=nt.pt;
        //int nc=nt.cost;
        if(vis[now]) continue;
        else vis[now]=1;
        for(int i=head[now];i;i=edge[i].next){
        	int next=edge[i].to;
        	if(dis[next]>dis[now]+edge[i].w){
        		dis[next]=dis[now]+edge[i].w;
        		if(!vis[next]){
        			fow to_push;
        			to_push.pt=next;
        			to_push.cost=dis[next];
        			q.push(to_push);
        		}
        	}
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=1;i<=n;i++) dis[i]=inf;
    for(int i=1;i<=m;i++){
        cin>>a>>b>>c;
        add(a,b,c);
    }
    dijkstra();
    for(int i=1;i<=n;i++){
    	cout<<dis[i]<<' ';
    }
    return 0;
}

最短路计数

SPFA的过程中dp
if(dis[next]==dis[now]+edge[i].w) cnt[next]+=cnt[now];

// luogu-judger-enable-o2
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
#define inf 2147483647
#define maxn 2000001
struct node
{
    int u,v;
    int w;
}edge[maxn];
int top=0;
int dis[maxn],vis[maxn],head[maxn],cnt[maxn];
void add(int from,int to,int dis) 
{ 
  edge[++top].u=head[from]; 
  edge[top].v=to; 
  edge[top].w=dis; 
  head[from]=top; 
}
int n,m,a,b,c;
void spfa(int s)
{
    queue <int> q;
    for(int i=1;i<=n;i++)
    {
        vis[i]=0;
        dis[i]=inf;
    }
    q.push(s);
    vis[s]=1;
    dis[s]=0;
    cnt[s]=1;
    while(!q.empty())
    {
    	int now=q.front();
    	q.pop();
    	vis[now]=0;
    	for(int i=head[now];i;i=edge[i].u)
    	{
    		int next=edge[i].v;
    		if(dis[next]>dis[now]+edge[i].w)
    		{
    			dis[next]=dis[now]+edge[i].w;
    			cnt[next]=cnt[now];
    			if(!vis[next])
    			{
    				q.push(next);
    				vis[next]=1;
                }
            }
            else if(dis[next]==dis[now]+edge[i].w){
            	cnt[next]+=cnt[now];
            	cnt[next]%=100003;
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>a>>b;
        add(a,b,1);
        add(b,a,1);
    }
    spfa(1);
    for(int i=1;i<=n;i++){
    	cout<<cnt[i]<<endl;
    }
    return 0;
}

SPFA判负环

一个点最多被访问n-1次吧。。
然后如果访问次数>=n就有负环
复杂度应该不太高

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int read(){
    int x=0;char ch=getchar();bool pos=1;
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') pos=0;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
    return pos?x:-x;
}
int n,m,head[300001],top=0,dis[300001],cnt[300001],vis[300001];
struct node{
    int to,next,w;
}edge[300001];
void add(int from,int to,int w){
    edge[++top].to=to;
    edge[top].w=w;
    edge[top].next=head[from];
    head[from]=top;
}
int spfa(){
    for(int i=1;i<=n;i++){
        dis[i]=999999999;
        vis[i]=0;
        cnt[i]=0;
    }
    vis[1]=1;
    dis[1]=0;
    queue<int>q;
    q.push(1);
    while(!q.empty()){
        int now=q.front();
        vis[now]=0;
        q.pop();
        for(int i=head[now];i;i=edge[i].next){
            int next=edge[i].to;
            if(dis[next]>dis[now]+edge[i].w){
                dis[next]=dis[now]+edge[i].w;
                cnt[now]++;
                if(cnt[now]>=n) return 1;
                if(!vis[next]){
                    vis[next]=1;
                    q.push(next);
                }
            }
        }
    }
    return 0;
}
void solve(){
    n=read();m=read();
    memset(head,0,sizeof(head));
    for(int i=1;i<=m;i++){
        int x=read(),y=read(),w1=read();
        add(x,y,w1);
        if(w1>=0) add(y,x,w1);
    }
    if(spfa()) cout<<"YE5\n";
    else cout<<"N0\n";
    return;
}
int main(){
    int t=read();
    for(int i=1;i<=t;i++){
        top=0;
        solve();
    }
    return 0;
}