Bellman-Ford最短路

//队列优化 O(VE)
const int MAXN = 1e5+5;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int from,to,dist;
    Edge(int u,int v,int w):from(u),to(v),dist(w){    }
};
struct SPFA
{
    int n,m;
    vector<Edge>edges;
    vector<int>G[MAXN];
    bool vis[MAXN];
    int d[MAXN];
    int p[MAXN];
    int cnt[MAXN];
    void init(int n)
    {
        this->n = n;
        edges.clear();
        for(int i=0;i<=n;i++)G[i].clear();
    } 
    void AddEdge(int from,int to,int dist)
    {
        edges.push_back(Edge(from,to,dist));
        m = edges.size();
        G[from].push_back(m-1);
    }
    bool spfa(int s)
    {
        for(int i=0;i<=n;i++)d[i] = INF;
        memset(vis,0,sizeof(vis));
        memset(cnt,0,sizeof(cnt));
        d[s] = 0; vis[s] = true;
        queue<int>Q;
        Q.push(s);
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            vis[u] = false;
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e = edges[G[u][i]];
                if(d[u] < INF && d[e.to] > d[u] +e.dist)
                {
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];
                    if(!vis[e.to])
                    {
                        Q.push(e.to);vis[e.to] = true;
                        if(++cnt[e.to] > n)return false; 
                    }
                 } 
            }
        }
        return true;
    }
}solve;