给出一个c++写的简易SPFA算法

好的，请参考以下代码实现简易SPFA算法：

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;

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

struct Edge {
    int to, weight;
};

vector<Edge> G[MAXN];
int dis[MAXN];
bool visited[MAXN];
int cnt[MAXN];

void spfa(int s) {
    queue<int> q;
    memset(dis, INF, sizeof(dis));
    memset(visited, false, sizeof(visited));
    memset(cnt, 0, sizeof(cnt));
    dis[s] = 0;
    visited[s] = true;
    cnt[s]++;
    q.push(s);

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        visited[u] = false;
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].to;
            int weight = G[u][i].weight;
            if (dis[v] > dis[u] + weight) {
                dis[v] = dis[u] + weight;
                if (!visited[v]) {
                    q.push(v);
                    visited[v] = true;
                    cnt[v]++;
                    if (cnt[v] >= N) {
                        printf("存在负环\n");
                        return;
                    }
                }
            }
        }
    }
}

int main() {
    int N, M; // N表示节点数，M表示边数
    cin >> N >> M;
    for (int i = 1; i <= M; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        G[u].push_back((Edge) {
            v, w
        });
    }
    spfa(1);
    for (int i = 1; i <= N; i++) {
        cout << dis[i] << " ";
    }
    return 0;
}

SPFA算法是一种解决单源最短路径问题的算法，可以处理有向图或者有向带权图，时间复杂度为O(kE)，k是松弛操作的次数，通常情况下k<2，因此SPFA的平均时间复杂度约为O(E)。