Problem:
Score : 600 points

Problem Statement

We have N points numbered 1 to N arranged in a line in this order.

Takahashi decides to make an undirected graph, using these points as the vertices.
In the beginning, the graph has no edge. Takahashi will do M operations to add edges in this graph.
The i-th operation is as follows:

The operation uses integers L_i and R_i between 1 and N (inclusive), and a positive integer C_i. For every pair of integers (s, t) such that L_i \leq s < t \leq R_i, add an edge of length C_i between Vertex s and Vertex t.

The integers L_1, ..., L_M, R_1, ..., R_M, C_1, ..., C_M are all given as input.

Takahashi wants to solve the shortest path problem in the final graph obtained. Find the length of the shortest path from Vertex 1 to Vertex N in the final graph.

Constraints

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq L_i < R_i \leq N

1 \leq C_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
L_1 R_1 C_1
:
L_M R_M C_M

Output

Print the length of the shortest path from Vertex 1 to Vertex N in the final graph.
If there is no shortest path, print -1 instead.

Sample Input 1

4 3
1 3 2
2 4 3
1 4 6

Sample Output 1

5

We have an edge of length 2 between Vertex 1 and Vertex 2, and an edge of length 3 between Vertex 2 and Vertex 4, so there is a path of length 5 between Vertex 1 and Vertex 4.

Sample Input 2

4 2
1 2 1
3 4 2

Sample Output 2

-1

Sample Input 3

10 7
1 5 18
3 4 8
1 3 5
4 7 10
5 9 8
6 10 5
8 10 3

Sample Output 3

28

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<ll,ll> ii;
typedef pair<ii,ll> iii;
#define REP(i,n) for(ll i=0;i<n;i++)
#define REP1(i,n) for(ll i=1;i<=n;i++)
#define RREP(i,n) for (ll i=n-1;i>=0;i--)
#define RST(i,n) memset(i,n,sizeof i)
#define SZ(a) (ll)a.size()
#define ALL(a) a.begin(),a.end()
#define X first
#define Y second
#define mkp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#ifdef cold66
#define debug(...) do{\
    fprintf(stderr,"%s - %d (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
    _do(__VA_ARGS__);\
}while(0)
template<typename T>void _do(T &&_x){cerr<<_x<<endl;}
template<typename T,typename ...S> void _do(T &&_x,S &&..._t){cerr<<_x<<", ";_do(_t...);}
template<typename _a,typename _b> ostream& operator << (ostream &_s,const pair<_a,_b> &_p){return _s<<"("<<_p.X<<","<<_p.Y<<")";}
template<typename It> ostream& _OUTC(ostream &_s,It _ita,It _itb)
{
    _s<<"{";
    for(It _it=_ita;_it!=_itb;_it++)
    {
        _s<<(_it==_ita?"":",")<<*_it;
    }
    _s<<"}";
    return _s;
}
template<typename _a> ostream &operator << (ostream &_s,vector<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,set<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a,typename _b> ostream &operator << (ostream &_s,map<_a,_b> &_c){return _OUTC(_s,ALL(_c));}
template<typename _t> void pary(_t _a,_t _b){_OUTC(cerr,_a,_b);cerr<<endl;}
#define IOS()
#else
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() ios_base::sync_with_stdio(0);cin.tie(0);
#endif // cold66
//}
template<class T> inline bool chkmax(T &a, const T &b) { return b > a ? a = b, true : false; }
template<class T> inline bool chkmin(T &a, const T &b) { return b < a ? a = b, true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;

const ll MAXn=1e5+5,MAXlg=__lg(MAXn)+2;
const ll MOD=1000000007;
const ll INF=0x3f3f3f3f3f3f3f3f;

struct inv{
    ll l,r,c;
    bool operator < (const inv &a) const {
        return c > a.c;
    }
};
pair<ii,ll> d[MAXn];
priority_queue<inv> pq;
ll seg[MAXn*4],tg[MAXn*4];
void pull(ll id){
    ll lc = min(seg[id*2+1],(tg[id*2+1] == -1 ?INF:tg[id*2+1]));
    ll rc = min(seg[id*2+2],(tg[id*2+2] == -1 ?INF:tg[id*2+2]));
    seg[id] = min(lc,rc);
}
void push(ll id){
    if (tg[id] == -1) return;
    seg[id] = min(seg[id],tg[id]);
    if (tg[id*2+1] == -1) tg[id*2+1] = tg[id];
    else tg[id*2+1] = min(tg[id*2+1],tg[id]);
    if (tg[id*2+2] == -1) tg[id*2+2] = tg[id];
    else tg[id*2+2] = min(tg[id*2+2],tg[id]);
    tg[id] = -1;
}
void build(ll id,ll L,ll R){
    tg[id] = -1;
    if (L == R-1) {
        seg[id] = INF;
        return;
    }
    ll mid = (L+R)>>1;
    build(id*2+1,L,mid);
    build(id*2+2,mid,R);
    pull(id);
}
void ins(ll id,ll L,ll R,ll l,ll r,ll v){
    // debug(id,L,R);
    if (l == L && r == R) {
        if (tg[id] == -1) tg[id] = v;
        else tg[id] = min(tg[id],v);
        // debug(id,tg[id]);
        return;
    }
    push(id);
    ll mid = (L+R)>>1;
    if (r <= mid) ins(id*2+1,L,mid,l,r,v);
    else if (l >= mid) ins(id*2+2,mid,R,l,r,v);
    else {
        ins(id*2+1,L,mid,l,mid,v);
        ins(id*2+2,mid,R,mid,r,v);
    }
    pull(id);
}
ll qr(ll id,ll L,ll R,ll l,ll r){
    // debug(id,L,R,seg[id],tg[id]);
    if (l == L && r == R) {
        return min(seg[id],(tg[id] == -1 ?INF:tg[id]));
    }
    push(id);
    ll mid = (L+R)>>1;
    if (r <= mid) return qr(id*2+1,L,mid,l,r);
    else if (l >= mid) return qr(id*2+2,mid,R,l,r);
    else {
        ll lc = qr(id*2+1,L,mid,l,mid);
        ll rc = qr(id*2+2,mid,R,mid,r);
        return min(lc,rc);
    }
}
int main(){
    IOS();
    ll n,m;
    cin >> n >> m;
    REP (i,m) {
        cin >> d[i].X.X >> d[i].X.Y >> d[i].Y;
    }
    sort(d,d+m);
    build(0,0,n);
    ins(0,0,n,0,1,0);

    // debug(qr(0,0,n,0,1));

    ll idx = 0;
    ll mx = 0;
    while (idx < m && d[idx].X.X == 1) {
        debug(d[idx]);
        pq.emplace(inv{d[idx].X.X,d[idx].X.Y,d[idx].Y});
        idx++;
    }
    while (SZ(pq)) {
        inv cur = pq.top();
        pq.pop();
        debug(cur.l,cur.r,cur.c);
        ll mn = qr(0,0,n,cur.l-1,cur.r);
        mx = max(mx,cur.r);
        debug(mn,mx);
        ins(0,0,n,cur.l-1,cur.r,cur.c + mn);
        while (idx < m && d[idx].X.X <= mx) {
            pq.emplace(inv{d[idx].X.X,d[idx].X.Y,d[idx].Y});
            idx++;
        }
    }
    ll ans = qr(0,0,n,n-1,n);
    if (ans >= INF) cout << -1 << endl;
    else cout << ans << endl;
}