最短路模板集.

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

const int INF=0x3f3f3f3f;
const int MAXN=10000;
int n,s;
int dist[MAXN];
int cost[MAXN][MAXN];
bool vis[MAXN];

void dijkstra(int s)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<MAXN;i++)
        dist[i]=INF;
    dist[s]=0;
    while(1)
    {
        int v=-1;
        for(int u=0;u<n;u++)
            if(!vis[u]&&(v==-1||dist[u]<dist[v])
                v=u;
        if(v==-1)
            break;
        vis[v]=true;
        for(int u=0;u<n;u++)
            dist[u]=min(dist[u],dist[v]+cost[v][u]);
            
    }
}

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

const int INF=0x3f3f3f3f;
const int MAXN=10000;

struct Edge{
    int v,w;
}G[MAXN];
int n,s;
int dist[MAXN];
bool vis[MAXN];

void dijkstra(int s)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<MAXN;i++)
        dist[i]=INF;
    dist[s]=0;
    while(1)
    {
        int v=-1;
        for(int u=0;u<n;u++)
            if(!vis[u]&&(v==-1||dist[u]<dist[v])
                v=u;
        if(v==-1)
            break;
        vis[v]=true;
        for(int u=0;u<G[v].size();u++)
        {
            int to=G[v][u].v;
            int w=G[v][u].w;
            dist[to]=min(dist[to],dist[v]+w);
        }
    }
}

const int INF=0x3f3f3f3f;
const int MAXN=1000;
const int MAXM=1000000;
typedef pair<int,int> P;
struct Edge{
    int to,cost;
}G[MAXM];

int dist[MAXN];
int V,E;

void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> > que;
    fill(dist,dist+V,INF);
    dist[s]=0;
    while(!que.empty())
    {
        P p=que.top();que.pop();
        int v=p.second;
        if(dist[v]<p.first) continue;
        for(int i=0;i<G[v].size();i++)
        {
            Edge e=G[v][i];
            if(dist[e.to]>dist[v]+e.cost)
            {
                dist[e.to]=dist[v]+e.cost;
                que.push(P(dist[e.to],e.to));
            }
        }
    }
}

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

using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=1000;
const int MAXM=1000000;

struct Edge{
    int from,to,w;
}E[MAXM];

int dist[MAXN];
int V,E;

void bell_man(int s)
{
    for(int i=0;i<V;i++)
        dist[i]=INF;
    dist[s]=0;
    while(1)
    {
        bool update=false;
        for(int i=0;i<E;i++)
        {
            Edge e=E[i];
            if(dist[e.from]!=INF&&dist[e.to]>dist[e.from]+e.cost)
            {
                dist[e.to]=dist[e.from]+e.cost;
                update=true;
            }
        }
        if(!update)
            break;
    }
}

const int MAXN=1010;
const int INF=0x3f3f3f3f;
struct Edge{
    int v,cost;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<Edge>E[MAXN];
void addedge(int u,int v,int w)
{
    E[u].push_back(Edge(v,w));
}
bool vis[MAXN];
bool cnt[MAXN];
bool dist[MAXN];
bool SPFA(int s,int n)
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) dist[i]=INF;
    vis[s]=true;
    dist[s]=0;
    queue<int>que;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=true;
        for(int i=0;i<E[u].size();i++)
        {
            int v=E[u][i].v;
            if(dist[v]>dist[u]+E[u][i].cost)
            {
                dist[v]=dist[u]+E[u][i].cost;
                if(!vis[v])
                {
                    vis[v]=true;
                    que.push(v);
                    if(++cnt[v]>n)
                        return false;
                }
            }
        }
    }
    return true;
}