/*题意：求符合题意的最小集合的元素个数

 题目要求的是求的最短路，

 则对于 不等式  f(b)-f(a)>=c,建立 一条 b 到 a 的边 权值为 c,则求的最长路 即为 最小值(集合)

 并且有隐含条件：0<=f(a)-f(a-1)<=1  则有边权关系(a,a-1,0)以及(a-1,a,-1);

 将源点到各点的距离初始化为INF(无穷大)，其中之1为0，最终求出的最短路满足 它们与该点之间相互差值最大

 差分约束

 　在实际的应用中，一般使用SPFA(Shortest Path Fast Algorithm)算法来实现。

 　　差分约束系统中源点到每个点的距离确定

 　　关于Dist[]的初始化化

 　　1.如果将源点到各点的距离初始化为0，最终求出的最短路满足 它们之间相互最接近了

 　　2.如果将源点到各点的距离初始化为INF(无穷大)，其中之1为0，最终求出的最短路满足 它们与该点之间相互差值最大。

 　　3.差分约束系统的确立要根据自己确定的约束条件，从约束点走向被约束点

 　　连边一般有两种方法，第一种是连边后求最长路的方法，第二种是连边后求最短路的方法。

 　　例：d[x]-d[y]>=Z

 　　如果想连边后求最长路 那么将不等式变形为这种形式 d[x]>=d[y]+z y---x连一条权值为z的边

 　　求最短路则变形成d[y]<=d[x]-z x---y连一条权值为-z的边。

 　　如果是别的不等式，也可以根据情况变形。但是要保证的是 两个变量（x,y)的系数一定要是正的。而常量则不一定。

 第一：

 感觉难点在于建图

 第二：

 ①：对于差分不等式，a - b <= c ，建一条 b 到 a 的权值为 c 的边，求的是最短路，得到的是最大值

 ②：对于不等式 a - b >= c ，建一条 b 到 a 的权值为 c 的边，求的是最长路，得到的是最小值

 ③：存在负环的话是无解

 ④：求不出最短路（dist[ ]没有得到更新）的话是任意解

 第三：

 一种建图方法：

 设x[i]是第i位置（或时刻）的值（跟所求值的属性一样），那么把x[i]看成数列，前n项和为s[n]，则x[i] = s[i] - s[i-1]；

 那么这样就可以最起码建立起类似这样的一个关系：0 <= s[i] - s[i-1] <= 1;

 其他关系就要去题目探索了

 */

 #include<iostream>

 #include<algorithm>

 #include<cstdio>

 #include<queue>

 #include<memory.h>

 using namespace std;

 const int MAXSIZE=;

 const int INF=0x3fffff;

 int dis[MAXSIZE],mmin,mmax,n,cnt,head[MAXSIZE],vis[MAXSIZE];

 struct node{

     int u,v,val,next;

 } Edge[MAXSIZE<<];

 void addEdge(int u,int v,int val){

     Edge[cnt].u=u;

     Edge[cnt].v=v;

     Edge[cnt].val=val;

     Edge[cnt].next=head[u];

     head[u]=cnt++;

 }

 int spfa(int src,int ter){

     for(int i=src;i<=ter;i++) dis[i]=-INF;

     deque<int>q;

     q.push_back(src);

     vis[src] = ;//标记当前顶点是否在队列中

     dis[src] = ;

     while(!q.empty()){

         int u = q.front();

         q.pop_front();

         vis[u] = ;

         for(int i = head[u];i != -;i = Edge[i].next){

             int v = Edge[i].v;

             if(dis[v] < dis[u] + Edge[i].val){//松弛

                 dis[v] = dis[u] + Edge[i].val;

                 if(!vis[v]){

                     vis[v] = ;

                     if(!q.empty()&&dis[v]<dis[q.front()])//SLF优化

                         q.push_front(v);

                     else q.push_back(v);

                 }

             }

         }

     }

     return dis[ter];

 }

 void SPFA(){

     for(int i=mmin;i<=mmax;i++) dis[i]=-INF;

     queue<int>q;

     q.push(mmin);

     vis[mmin]=;

     dis[mmin]=;

     while(!q.empty()){

         int u=q.front();

         q.pop();

         vis[u]=;

         for(int i=head[u]; i!=-; i=Edge[i].next){

             int v=Edge[i].v;

             if(dis[v]<dis[u]+Edge[i].val){

                 dis[v]=dis[u]+Edge[i].val;

                 if(!vis[v])

                 {

                     vis[v]=;

                     q.push(v);

                 }

             }

         }

     }

     printf("%d\n",dis[mmax]);

 }

 int main(){

     int a,b,c,i,j;

     while(scanf("%d",&n)!=EOF){

         memset(head,-,sizeof(head));

         memset(vis,,sizeof(vis));

         cnt=;

         mmin = MAXSIZE;

         mmax = ;

         for(i=; i<=n; i++){

             scanf("%d%d%d",&a,&b,&c);

             b++;

             if(mmin>a)  mmin=a;

             if(mmax<b)  mmax=b;

             addEdge(a,b,c);

         }

         for(i=mmin; i<mmax; i++){

             addEdge(i+,i,-);

             addEdge(i,i+,);

         }

         //spfa();

         printf("%d\n",spfa(mmin,mmax));

     }

     return ;

 }

//双向队列 deque

//by MoreWindows http://blog.csdn.net/morewindows

#include <deque>

#include <cstdio>

#include <algorithm>

using namespace std;

int main()

{

    deque<int> ideq(); //Create a deque ideq with 20 elements of default value 0

    deque<int>::iterator pos;

    int i;

    //使用assign()赋值  assign在计算机中就是赋值的意思

    for (i = ; i < ; ++i)

        ideq[i] = i;

    //输出deque

    printf("输出deque中数据:\n");

    for (i = ; i < ; ++i)

        printf("%d ", ideq[i]);

    putchar('\n');

    //在头尾加入新数据

    printf("\n在头尾加入新数据...\n");

    ideq.push_back();

    ideq.push_front(i);

    //输出deque

    printf("\n输出deque中数据:\n");

    for (pos = ideq.begin(); pos != ideq.end(); pos++)

        printf("%d ", *pos);

    putchar('\n');

    //查找

    const int FINDNUMBER = ;

    printf("\n查找%d\n", FINDNUMBER);

    pos = find(ideq.begin(), ideq.end(), FINDNUMBER);

    if (pos != ideq.end())

        printf("find %d success\n", *pos);

    else

        printf("find failed\n");

    //在头尾删除数据

    printf("\n在头尾删除数据...\n");

    ideq.pop_back();

    ideq.pop_front();

    //输出deque

    printf("\n输出deque中数据:\n");

    for (pos = ideq.begin(); pos != ideq.end(); pos++)

        printf("%d ", *pos);

    putchar('\n');

    return ;

}