最短路模板（Dijkstra，SPFA，Floyd）

最短路模板

Dijkstra

const int maxn = 1e4 + 5;
const int inf = 0x3f3f3f3f;
struct node
{
    int v, w;
    bool operator<(const node &p) const
    {
        return w > p.w;
    }
} a[maxn];
vector<node> v[maxn];
bool vis[maxn];
int dis[maxn];
void dij(int k)
{
    memset(vis, true, sizeof(vis));
    memset(dis, inf, sizeof(dis));
    dis[k] = 0;
    priority_queue<node> q;
    q.push({k, dis[k]});
    while (!q.empty())
    {
        node p;
        p = q.top();
        q.pop();
        if (vis[p.v])
            continue;
        vis[p.v] = true;
        for (int i = 0; i < v[p.v].size(); i++)
        {
            node t = v[p.v][i];
            if (!vis[t.v] && dis[t.v] > dis[p.v] + t.w)
            {
                dis[t.v] = dis[p.v] + t.w;
                q.push({t.v, dis[t.v]});
            }
        }
    }
}

SPFA

const int maxn = 1e4 + 5;
const int inf = 0x3f3f3f3f;
struct node
{
    int v, w;
};
vector<node> v[maxn];
int dis[maxn];
bool inq[maxn];
void spfa(int k)
{
    memset(dis, inf, sizeof(dis));
    memset(inq, false, sizeof(inq));
    queue<int> q;
    q.push(k);
    inq[k] = true;
    dis[1] = 0;
    while (!q.empty())
    {
        int t = q.front();
        q.pop();
        inq[t] = false;
        for (int i = 0; i < v[t].size(); i++)
        {
            node p = v[t][i];
            if (dis[p.v] > dis[t] + p.w)
            {
                dis[p.v] = dis[t] + p.w;
                if (!inq[p.v])
                {
                    q.push(p.v);
                    inq[p.v] = true;
                }
            }
        }
    }
}

Floyd

const int maxn = 1e4 + 5;
const int inf = 0x3f3f3f3f;
int dis[maxn][maxn];
void Floyd(int n)
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                dis[i][j]=0;
            else
                dis[i][j]=inf;
        }
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
            }
        }
    }
}