CodeForces

题目链接：https://vjudge.net/problem/CodeForces-960F

You are given a directed graph with n nodes and m edges, with all edges having a certain weight.

There might be multiple edges and self loops, and the graph can also be disconnected.

You need to choose a path (possibly passing through same vertices multiple times) in the graph such that the weights of the edges are in strictly increasing order, and these edges come in the order of input. Among all such paths, you need to find the the path that has the maximum possible number of edges, and report this value.

Please note that the edges picked don't have to be consecutive in the input.

Input

The first line contains two integers n and m (1 ≤ n ≤ 100000,1 ≤ m ≤ 100000) — the number of vertices and edges in the graph, respectively.

m lines follows.

The i-th of these lines contains three space separated integers a_i, b_i and w_i (1 ≤ a_i, b_i ≤ n, 0 ≤ w_i ≤ 100000), denoting an edge from vertex a_i to vertex b_i having weight w_i

Output

Print one integer in a single line — the maximum number of edges in the path.

Examples

Input

3 3
3 1 3
1 2 1
2 3 2

Output

2

Input

5 5
1 3 2
3 2 3
3 4 5
5 4 0
4 5 8

Output

3

Note

The answer for the first sample input is 2: . Note that you cannot traverse  because edge  appears earlier in the input than the other two edges and hence cannot be picked/traversed after either of the other two edges.

In the second sample, it's optimal to pick 1-st, 3-rd and 5-th edges to get the optimal answer: .

题意：

给出n个结点和m条带权有向边，其中可以有环、自环。一条合法的路径为：路径上边的给出次序（输入次序）和权值都满足严格递增，问最长的合法路径？

题解：

1.由于路径需满足“边的给出次序递增”，即只能从先给出的边走到后给出的边，且又需满足“权值严格单调递增”，所以就是一道类LIS的题目。

2.为每个点开一棵线段树，由于边只有1e5条，故使用动态开点就不会超内存。线段树以边权作为区间，每个结点需记录三个信息：左、右孩子，以及当前值能形成的最长路径。

3.剩下的操作与LIS或二维偏序差不多了。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <sstream>
#include <algorithm>
using namespace std;
typedef long long LL;
const double eps = 1e-8;
const int INF = 2e9;
const LL LNF = 9e18;
const int MOD = 1e9+7;
const int MAXN = 2e6+10;

struct node
{
    int lson, rson, cnt;
    void init()
    {
        lson = rson = -1;
        cnt = 0;
    }
}q[MAXN];
int root[MAXN], tot;

void add(int &rt, int l, int r, int val, int cnt)
{
    if(rt==-1)  //动态开点
    {
        rt = tot++;
        q[rt].init();
    }
    q[rt].cnt = max(q[rt].cnt,cnt);
    if(l==r) return;

    int mid = (l+r)>>1;
    if(val<=mid) add(q[rt].lson, l, mid, val, cnt);
    else add(q[rt].rson, mid+1, r, val, cnt);
}

int query(int rt, int l ,int r, int x,int y)
{
    if(rt==-1) return 0;    //如果此处没有开点，即表明此处没有插入值，直接返回0
    if(x<=l&&r<=y) return q[rt].cnt;

    int mid = (l+r)>>1;
    int ret = 0;
    if(x<=mid) ret = max(ret, query(q[rt].lson, l, mid, x, y));
    if(y>=mid+1) ret = max(ret, query(q[rt].rson, mid+1, r, x, y));
    return ret;
}

int main()
{
    int n, m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        tot = 0;
        memset(root, -1, sizeof(root));
        int ans = 0;
        for(int i = 1; i<=m; i++)
        {
            int u, v, w;
            scanf("%d%d%d",&u,&v,&w);
            int max_cnt = query(root[u],-1, 100000, -1,w-1);    //最小值为-1，防止w-1溢出范围
            ans = max(ans, max_cnt+1);
            add(root[v], -1, 100000, w, max_cnt+1);
        }
        printf("%d
", ans);
    }
}