AcWing 342. 道路与航线 （连通块Dijkstra+拓扑序||spfa+slf优化）

整理的算法模板：ACM算法模板总结（分类详细版）

 

农夫约翰正在一个新的销售区域对他的牛奶销售方案进行调查。

他想把牛奶送到T个城镇，编号为1~T。

这些城镇之间通过R条道路 (编号为1到R) 和P条航线 (编号为1到P) 连接。

每条道路 ii 或者航线 ii 连接城镇AiAi到BiBi，花费为CiCi。

对于道路，0≤Ci≤10,0000≤Ci≤10,000;然而航线的花费很神奇，花费CiCi可能是负数(−10,000≤Ci≤10,000−10,000≤Ci≤10,000)。

道路是双向的，可以从AiAi到BiBi，也可以从BiBi到AiAi，花费都是CiCi。

然而航线与之不同，只可以从AiAi到BiBi。

事实上，由于最近恐怖主义太嚣张，为了社会和谐，出台了一些政策：保证如果有一条航线可以从AiAi到BiBi，那么保证不可能通过一些道路和航线从BiBi回到AiAi。

由于约翰的奶牛世界公认十分给力，他需要运送奶牛到每一个城镇。

他想找到从发送中心城镇S把奶牛送到每个城镇的最便宜的方案。

输入格式

第一行包含四个整数T,R,P,S。

接下来R行，每行包含三个整数（表示一个道路）Ai,Bi,CiAi,Bi,Ci。

接下来P行，每行包含三个整数（表示一条航线）Ai,Bi,CiAi,Bi,Ci。

输出格式

第1..T行：第i行输出从S到达城镇i的最小花费，如果不存在，则输出“NO PATH”。

数据范围

1≤T≤250001≤T≤25000,
1≤R,P≤500001≤R,P≤50000,
1≤Ai,Bi,S≤T1≤Ai,Bi,S≤T,

输入样例：

6 3 3 4
1 2 5
3 4 5
5 6 10
3 5 -100
4 6 -100
1 3 -10

输出样例：

NO PATH
NO PATH
5
0
-95
-100

 

两种做法：

• 连通块处理+dijkstra+拓扑序
• spfa+slf优化 

连通块处理+dijkstra+拓扑序：

y巨的思路是真牛掰；y巨巨不推荐用spfa然后再加上各种优化去做；但是我的脑子想不出来这种思路啊.......

具体图解为：

 

 

#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int N=25005,M=150000;
int e[M],ne[M],h[M],w[M],idx,id[N],inv[N],cnt,dis[N];
int n,r,p,s;
bool st[N];
vector<int> block[N];
queue<int> q;
void add(int a,int b,int c)
{
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
void dfs(int u,int bid)
{
    id[u]=bid;
    block[bid].push_back(u);
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!id[j])
        {
            dfs(j,bid);
        }
    }
}
void dijkstra(int root)
{
    priority_queue<PII,vector<PII>,greater<PII> > heap;
    for(auto i : block[root])
    {
        heap.push({dis[i],i});
    }
    while(!heap.empty())
    {
        auto res=heap.top();
        heap.pop();
        int ver=res.second,distance=res.first;
        if(st[ver]) continue;
        st[ver]=true;
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(id[ver]!=id[j]&&--inv[id[j]]==0) q.push(id[j]);
            if(dis[j]>distance+w[i])
            {
                dis[j]=distance+w[i];
                if(id[j]==id[ver]) heap.push({dis[j],j});
            }
        }
    }
}
void topsort()
{
    memset(dis,0x3f,sizeof dis);
    memset(st,false,sizeof st);
    dis[s]=0;
    for(int i=1;i<=cnt;i++)
    {
        if(!inv[i]) q.push(i);
    }
    while(!q.empty())
    {
        int res=q.front();
        q.pop();
        dijkstra(res);
    }
}
int main()
{
    memset(h,-1,sizeof h);
    cin >>n>>r>>p>>s;
    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<=n;i++)
    {
        if(!id[i])
        {
            cnt++;
            dfs(i,cnt);
        }
    }
    for(int i=0;i<p;i++)
    {
        int a,b,c;
        cin >>a>>b>>c;
        add(a,b,c);
        inv[id[b]]++;
    }
    topsort();
    for (int i = 1; i <= n; i ++ )
    {
        if (dis[i] > 0x3f3f3f3f / 2) cout << "NO PATH" << endl;
        else cout << dis[i] << endl;
    }
}

 

SPFA+SLF优化：

SLF优化其实就是把spfa算法里面的普通队列优化改成了双端队列优化；

当 当前更新过的最短距离dis小于队列的队头，那么就加到队头；反之加到队尾；

#include <bits/stdc++.h>
using namespace std;
const int N=25005,M=150000;
int e[M],ne[M],h[M],w[M],idx,dis[N];
int n,r,p,s;
bool st[N];
void add(int a,int b,int c)
{
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
void spfa(int root)
{
    deque<int> q;
    memset(dis,0x3f,sizeof dis);
    dis[root]=0;
    q.push_back(root);
    st[root]=1;
    while(!q.empty())
    {
        int res=q.front();
        q.pop_front();
        st[res]=false;
        for(int i=h[res];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dis[j]>dis[res]+w[i])
            {
                dis[j]=dis[res]+w[i];
                if(!st[j])
                {
                    st[j]=true;
                    if(dis[j]>dis[q.front()]) q.push_back(j);
                    else q.push_front(j);
                }
            }
        }
    }
}
int main()
{
    memset(h,-1,sizeof h);
    cin >>n>>r>>p>>s;
    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=0;i<p;i++)
    {
        int a,b,c;
        cin >>a>>b>>c;
        add(a,b,c);
    }
    spfa(s);
    for(int i=1;i<=n;i++)
    {
        if(dis[i]==0x3f3f3f3f) cout <<"NO PATH"<<endl;
        else cout <<dis[i]<<endl;
    }
}