最短路板子--------笔记

堆优化的Dijkstra算法

Dijkstra求最短路

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;
const int N = 150010;
typedef pair<int,int> PII;

int h[N],idx;
int d[N];
int n,m;
bool st[N];

struct Edge
{
    int next;
    int to;
    int val;
}edge[N];

void add(int a,int b,int w)
{
    edge[idx].to = b;
    edge[idx].val = w;
    edge[idx].next = h[a];
    h[a] = idx++;
}

int Dijkstra()
{
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    heap.push({0,1});

    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ID = t.second,dist = t.first;
        if (st[ID]) continue;
        st[ID] = true;
        for (int i = h[ID]; ~i; i = edge[i].next)
        {
            int j = edge[i].to;
            int value = edge[i].val;
            if (d[j]>dist+value)
            {
                d[j] = dist+value;
                heap.push({d[j],j});
            }
        }
    }
    if (d[n] == 0x3f3f3f3f) return -1;
    return d[n];
}
int main ()
{
    memset(h,-1,sizeof h);
    memset(d,0x3f,sizeof d);
    d[1] = 0;
    scanf("%d%d",&n,&m);

    while(m -- )
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        add(a,b,w);
    }

    printf("%d\n",Dijkstra());
    return 0;
}

Bellman-Ford

有边数限制的最短路

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;
const int N = 510,M = 10010;

int n,m,k;
int d[N],backup[N];

struct Edge
{
    int a,b,w;
}edge[M];

int bellman_ford()
{
    memset(d,0x3f,sizeof d);
    d[1] = 0;
    
    for (int i = 1; i <= k; i++)
    {
        memcpy(backup,d,sizeof d);
        for (int j = 0; j < m; j++)
        {
            d[edge[j].b] = min(d[edge[j].b],backup[edge[j].a]+edge[j].w);
        }
    }
    
    if (d[n] > 0x3f3f3f3f/2) return -1;
    return d[n];
}

int main ()
{
    scanf("%d%d%d",&n,&m,&k);
    for (int i = 0; i < m; i++ )
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edge[i].a = a,edge[i].b = b,edge[i].w = w;
    }
    
    if (bellman_ford() == -1) puts("impossible");
    else printf("%d\n",bellman_ford());
    return 0;
}

SPFA

SPFA求最短路

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;
const int N = 1e5+10;

int n,m;
int h[N],idx,d[N];
bool st[N];

struct Edge
{
    int next;
    int to;
    int val;
}edge[N];

void add(int a,int b,int w)
{
    edge[idx].to = b;
    edge[idx].val = w;
    edge[idx].next = h[a];
    h[a] = idx++;
}

int Spfa()
{
    memset(d,0x3f,sizeof d);
    d[1] = 0;

    queue<int>q;
    q.push(1);
    st[1] = true;

    while(!q.empty())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; ~i; i = edge[i].next)
        {
            int j = edge[i].to;
            if (d[j]>d[t]+edge[i].val)
            {
                d[j] = d[t]+edge[i].val;
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (d[n] == 0x3f3f3f3f) return -1;
    return d[n];
}

int main ()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);

    while(m -- )
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        add(a,b,w);
    }

    if (Spfa() == -1) puts("impossible");
    else printf("%d\n",Spfa());
    return 0;
}

Floyd

Floyd求最短路

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;
const int N = 210,INF = 0x3f3f3f3f;

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

void floyd()
{
    for (int k = 1; k <= n; k++ )
    {
        for (int i = 1; i <= n; i++ )
        {
            for (int j = 1; j <= n; j++)
            g[i][j] = min(g[i][j],g[i][k]+g[k][j]);
        }
    }
}

int main ()
{
    scanf("%d%d%d",&n,&m,&k);
    for (int i = 1; i <= n; i++ )
    {
        for (int j = 1; j <= n; j++)
        {
            if (i == j) g[i][j] = 0;
            else g[i][j] = INF;
        }
    }


    while(m -- )
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        g[a][b] = min(g[a][b],w);
    }

    floyd();
    while(k --)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if (g[a][b] > INF/2) printf("impossible\n");
        else printf("%d\n",g[a][b]);
    }
    return 0;
}