最短路

我 讨 厌 静 电！！！

---

 最短路 - OI Wiki (oi-wiki.org)

最短路分类及时间复杂度

---

 

Floyd算法

是用来求任意两个结点之间的最短路的。

复杂度比较高，但是常数小，容易实现。（我会说只有三个 for 吗？）

适用于任何图，不管有向无向，边权正负，但是最短路必须存在。（不能有个负环）

三维的数组能够优化成二维数组进行计算

如图是三维数组思路及模板  暴力且无脑66

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=210;
const int INF=1e9;
const int mod=1e9+7;

int n,m,k;
int dist[N][N];

void Floyd()    //可以将三维Floyd的空间优化为二维进行计算
{
    
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]); //循环结束后dist[i][j]存的就是i到j的最短距离
    
}

void solve()
{
    
    cin >> n >> m >> k;
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(i==j)
                dist[i][j]=0;   //到自己的距离是0
            else
                dist[i][j]=INF;
    while(m--)
    {
        int a,b,c;
        cin >> a >> b >> c;
        dist[a][b]=min(dist[a][b],c);
    }
    
    Floyd();
    
    while(k--)
    {
        
        int a,b;
        cin >> a >> b;
        
        if(dist[a][b]>INF/2)
            cout << "impossible" << endl;
        else
            cout << dist[a][b] << endl;
        
    }
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}

---

松弛操作：

 

 

 

 

 

 （上图中左到右的距离在一次松弛操作中由4更新为3）

---

 

Bellman_Ford算法

 

 

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=510,M=10010;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;

struct node 
{
    int a,b,c;
}q[M];

int n,m,k;
int dist[N];
int last[N];

void Bellman_ford()
{
    
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        
        memcpy(last,dist,sizeof dist);  //将dist的数值存到last中
        for(int j=0;j<m;j++)
        {
            auto t=q[j];
            dist[t.b]=min(dist[t.b],last[t.a]+t.c);     //进行松弛操作
        }
        
    }
    
}

void solve()
{
    
    cin >> n >> m >> k;
    
    for(int i=0;i<m;i++)
    {
        
        int a,b,c;
        cin >> a >> b >> c;
        q[i]={a,b,c};
        
    }
    
    Bellman_ford();
    
    if(dist[n]>INF/2)
        cout << "impossible" << endl;
    else
        cout << dist[n] << endl;
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}

---

SPFA算法

只有上一次被松弛的结点，所连接的边，才有可能引起下一次的松弛操作。

很多时候我们并不需要那么多无用的松弛操作。

 

 

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=1e5+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;

int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N];

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

int Spfa()
{
    
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    queue<int> q;
    q.push(1);
    st[1]=true;
    
    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(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
        
    }
    return dist[n];
}

void solve()
{
    
    cin >> n >> m;
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
        
    }
    
    if(Spfa()>INF/2)
        cout << "impossible" << endl;
    else
        cout << Spfa() << endl;
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}

并常常用SPFA来判断负环是否存在

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=2010;
const int M=10010;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;

int n,m;
int h[N],e[M],ne[M],w[M],idx;
int dist[N],cnt[N];
bool st[N];

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

bool spfa()
{
    
    queue<int> q;
    
    for(int i=1;i<=n;i++)
    {
        st[i]=true;
        q.push(i);
    }
    
    while(q.size())
    {
        
        int t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int k=e[i];
            if(dist[k]>dist[t]+w[i])
            {
                dist[k]=dist[t]+w[i];
                cnt[k]=cnt[t]+1;
                
                if(cnt[k]>=n)
                    return true;
                if(!st[k])
                {
                    q.push(k);
                    st[k]=true;
                }
            }
        }
        
    }
    return false;
}

void solve()
{
    
    cin >> n >> m;
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
        
    }
    
    if(spfa())
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}

---

Dijkstra算法

 

 

 

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=510;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;

int n,m;
int g[N][N];    //邻接矩阵储存所有边权
int dist[N];    //存储1到各个点的距离
bool st[N];     //标记，判断是否走过

void Dijkstra()
{
    
    memset(dist,0x3f,sizeof dist);  //清空距离数组
    dist[1]=0;
    
    for(int i=0;i<n-1;i++)
    {
        
        int t=-1;
        
        for(int j=1;j<=n;j++)
            if(!st[j] && (t==-1 || dist[t]>dist[j]))    //选取一个最短路的点放入dist数组中
                t=j;
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],dist[t]+g[t][j]);   //将刚放入dist数组的点遍历进行松弛操作
        
        st[t]=true;
        
    }
    if(dist[n]>0x3f3f3f3f/2)
        cout << -1 << endl;
    else
        cout << dist[n] << endl;
    
}

void solve()
{
    
    cin >> n >> m;
    memset(g,0x3f,sizeof g);
    
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin >> a >> b >> c;
        
        g[a][b]=min(g[a][b],c); //求最短路时只需要存储两点之间最短的一条边就可以
    }
    
    Dijkstra();
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}

#include <bits/stdc++.h>
#define endl '\n'
#define x first
#define y second
#define int long long
#define Tang ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

using namespace std;

const int N=1e6+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;

typedef pair<int,int> PII;

int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N];

void add(int a,int b,int c) //数组模拟链表加入操作
{
    e[idx]=b,ne[idx]=h[a],w[idx]=c;h[a]=idx++;
}

int Dijkstra()
{
    
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    priority_queue<PII,vector<PII>,greater<PII>> q; //建立小根堆
    q.push({0,1});  //first是dist[i]，second是节点i
    
    while(q.size()) //当队列不空
    {
        
        auto t=q.top(); //每次取堆顶元素进行操作并将元素弹出
        q.pop();
        
        int dis=t.first,ver=t.second;
        
        if(st[ver])
            continue;
        st[ver]=true;
        
        for(int i=h[ver];i!=-1;i=ne[i]) //进行松弛操作
        {
            int j=e[i];
            if(dist[j]>dist[ver]+w[i])
            {
                dist[j]=dist[ver]+w[i]; //更新该点的最短路的dist值
                q.push({dist[j],j});    //将新进入的最短路的点放入队列中
            }
            
        }
        
    }
    if(dist[n]>0x3f3f3f3f/2)
        return -1;
    else
        return dist[n];
    
}

void solve()
{
    
    cin >> n >> m;
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        
        int a,b,c;
        cin >> a >> b >> c;
        add(a, b, c);
        
    }
    
    cout << Dijkstra() << endl;
    
}

signed main()
{
    Tang
    int T=1;
        //cin >> T;
    while(T--)
        solve();
    
    return 0;
        
}