poj3159

分糖果
poj3159
题意：
飞鼠分糖果 有点学生 A 不能比B少C即 B-A<=C

飞鼠喜欢和是莱蒂比 n 和 1 一共n 个人
s[i]表示第i学生分到的糖果
s[n]-s[1]
最大 最短路径
即从1出发 到 n的最短路径
m对约束
很显然差分约束

这题没有说不存在即没有负圈 而且肯定有答案肯定连通 （很水）
直接spfa 但是用队列会超
dijkstra 直接写

//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<cstring>
using namespace std;
typedef long long  ll;
const int INF=1e9+5;
const int maxn=3e4+5;
const int maxm=2e5+5;
int need[maxn];
int n,m;
int provide[maxn];
int dis[maxn];
int Neg[maxn];
bool vis[maxn];
bool inq[maxn];
stack <int >Q;
void init ()
{
    //memset(provide,0,sizeof(provide));
}
struct edge
{
    //int u;
    int v,next;
    int w;

};
struct qnode
{
    int v;
    int c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    bool operator <(const qnode &r)const
    {
        return c>r.c;
    }
};
struct node{
    int x;
    int dis;
    node(int _x=0,int _dis=0):x(_x),dis(_dis){}
    bool operator<(const node &b)const
    {
        return dis>b.dis;
    }
};
edge no[maxm];
int head[maxn];
int cnt;
priority_queue<node> que;
void pep()
{
    memset(head,0,sizeof(head));
    /*for(int i=0;i<=n;i++)
        head[i]=0;*/
    cnt=1;
}
void add(int x,int y,int w)
{
    //no[cnt].u=x;
    no[cnt].v=y;
    no[cnt].w=w;
    no[cnt].next=head[x];
    head[x]=cnt;
    cnt++;
}
void spfa(int s)
{
    memset(Neg,0,sizeof(Neg));///标记是否有负圈
    Neg[s]=1;
    while(!Q.empty())
        Q.pop();
    for(int i=0;i<=n;i++)
    {
        dis[i]=INF;
        inq[i]=false;///标记是否在队列
    }
    dis[s]=0;
    Q.push(s);
    inq[s]=true;

    while(!Q.empty())
    {
        int u=Q.top();
        Q.pop();
        inq[u]=false;
        //cout<<u<<endl;
        for(int i=head[u];i;i=no[i].next)
        {
            int v=no[i].v;
            int w=no[i].w;
            //cout<<v<<endl;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                //cout<<dis[v]<<endl;
                //pre[v]=u;
                if(!inq[v])
                {
                    inq[v]=true;
                    Q.push(v);
                    Neg[v]++;
                    if(Neg[v]>n){
                        //cout<<"有负圈";
                        //return 0;
                    }
                }

            }
        }
    }
    //cout<<dis[n]<<endl;
}
/*void Dijkstra(int s)
{
    for(int i=0;i<=n;i++)
    {
        dis[i]=INF;
        vis[i]=false;
    }
    while(!que.empty())
        que.pop();
    dis[s] = 0;
    que.push(node(s,0));
    node temp;
    while (!que.empty()) {
        temp = que.top();
        que.pop();
        int u=temp.x;
        if(vis[u])
            continue;
        vis[u]=true;
        for (int i=head[u];i!=0;i=no[i].next) {
            int v = no[i].v, len = no[i].w;
            if (!vis[v]&&dis[u] + len < dis[v]) {
                dis[v] = dis[u] + len;
                que.push(node(v,dis[v]));
            }
        }
    }
    //cout<<dis[n]<<"\n";
}*/
void solve()
{
    /*while(cin>>n>>m)
    {
        pep();
        for(int i=1;i<=m;i++)
        {
            int x,y,w;
            cin>>x>>y>>w;
            add(x,y,w);
        }
        Dijkstra(1);
        cout<<dis[n]<<"\n";
    }*/
    while(scanf("%d%d",&n,&m)==2)
    {
        pep();
        int A,B,C;
        while(m--)
        {
            scanf("%d%d%d",&A,&B,&C);
            add(A,B,C);
        }
        spfa(1);
        printf("%d\n",dis[n]);
    }
}
int main() {
    /*ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);*/
    int __=1;
    //cin>>__;
    while(__--)
    {
        //init();
        solve();
    }
    return 0;
}