BellmanFord判环算法

[code]#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXNODE = 510;
const int MAXEDGE = 100010;
typedef int Type;
const Type INF = 0x3f3f3f3f;

struct Edge{
    int u, v, next;
    Type dis;
    Edge() {}
    Edge(int u, int v, Type dis, int next): u(u), v(v), dis(dis), next(next) {}
};

struct BellmanFord{
    int n, m;
    Edge edges[MAXEDGE];
    bool inq[MAXNODE];
    Type d[MAXNODE];
    int p[MAXNODE], cnt[MAXNODE], head[MAXNODE];

    void init(int n) {
        this->n = n;
        memset(head, -1, sizeof(head));
        m = 0;
    }

    void AddEdge(int u, int v, Type dis) {
        edges[m] = Edge(u, v, dis, head[u]);
        head[u] = m++;
    }

    bool negativeCycle() {
        queue<int> Q;
        memset(inq, 0, sizeof(inq));
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < n; i++) {
            d[i] = INF;
            inq[i] = true;
            Q.push(i);
        }

        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            inq[u] = false;
            for (int i = head[u]; ~i; i = edges[i].next) {
                int v = edges[i].v;
                if (d[v] > d[u] + edges[i].dis) {
                    d[v] = d[u] + edges[i].dis;
                    if (!inq[v]) {
                        inq[v] = true;
                        Q.push(v);
                        if (++cnt[v] > n) return true;
                    }
                }
            }
        }
        return false;
    }

    bool positiveCycle() {
        queue<int> Q;
        memset(inq, 0, sizeof(inq));
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < n; i++) {
            d[i] = 0; inq[i] = true; Q.push(i);
        }

        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            inq[u] = false;
            for (int i = head[u]; ~i; i = edges[i].next) {
                int v = edges[i].v;
                if (d[v] < d[u] + edges[i].dis) {
                    d[v] = d[u] + edges[i].dis;
                    if (!inq[v]) {
                        inq[v] = true;
                        Q.push(v);
                        if (++cnt[v] > n) return true;
                    }
                }
            }
        }
        return false;
    }

}bell;

int main() {
    return 0;
}