利用Bellman-Ford算法（有向图） 判断负环

// 根据Bellman-Ford算法的原理
// 判断负环（算法的最大更新次数，应该是顶点数-1次）
// 而如果存在负环，算法会一直更新下去

// 我们根据循环进行的次数，来判断负环

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int max_N=1000+2;
const int max_E=10000+2;

int N,E;

struct edge
{
    int from,to,cost;
};
edge es[max_E];

int d[max_N];

void solve()
{
    memset(d,0,sizeof(d));
    int cnt=0;
    while(cnt<N)
    {
        bool update=false;
        for(int i=0;i<E;++i)
        {
            edge e=es[i];
            if(d[e.to]>d[e.from]+e.cost)
            {
                printf("hei  ");
                d[e.to]=d[e.from]+e.cost;
                update=true;
            }
        }
        if(update==false)
        {
            printf("NO
");
            break;
        }
        else
        {
            ++cnt;
            if(cnt==N)
            {
                printf("YES
");
                break;
            }
        }
    }
}

int main()
{
    scanf("%d %d",&N,&E);
    for(int i=0;i<E;++i)
    {
        scanf("%d%d%d",&es[i].from,&es[i].to,&es[i].cost);
    }
    solve();
    return 0;
}

/*
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9
NO
*/

/*
3 3
0 1 1
1 2 2
2 1 -2
NO
*/

/*
3 3
0 1 1
1 2 2
2 1 -3

*/